Computer implemented method for the automated analysis or use of data

ABSTRACT

A computer implemented method for the automated analysis or use of data is implemented by a voice assistant. The method comprises the steps of: (a) storing in a memory a structured, machine-readable representation of data that conforms to a machine-readable language (‘machine representation’); the machine representation including representations of user speech or text input to a human/machine interface; and (b) automatically processing the machine representations to analyse the user speech or text input.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. application Ser. No.18/001,368, filed on Dec. 9, 2022, which claims the priority ofInternational Application No. PCT/GB2021/052196, filed on Aug. 24, 2021,which claims priority to GB Application No. GB 2013207.2, filed on Aug.24, 2020; GB Application No. GB 2014876.3, filed Sep. 21, 2020; and GBApplication No. 2020164.6, filed on Dec. 18, 2020, the entire contentsof which are fully incorporated herein by reference.

BACKGROUND OF THE INVENTION 1. Field of the Invention

The field of the invention relates to a computer implemented method forthe automated analysis or use of data; one implementation is a voiceassistant that is able to analyse, interpret and act on natural languagespoken and text inputs.

2. Technical Background

Natural language (NL) is language evolved for humans such as the Englishlanguage. Although significant advances have been made in computers'ability to process natural language, computers are still not able todeeply understand the meaning of natural language and use that meaninginternally.

For this reason most computer applications typically use structured datato store information that they need for processing—e.g. a relationaldatabase: designing the schema, populating the database and writing codeto process the fields in the database.

Use of structured data can work well if the application has limitedrequirements for the type of data required. However, some applicationsnaturally require an extremely broad, heterogeneous collection of datato work well. This means that the schema required would have to beenormous, making building and coding for such an applicationimpractical. We refer to such applications herein as HUB applications(Heterogeneous and Unreasonably Broad).

Examples of HUB applications include an application for managing aperson's general health data where there are thousands of tests,thousands of medical conditions and thousands of symptoms. Anotherrelated application could be a nutrition tracking application wherethere are many thousands of substances and foods that can be ingested,each with different metabolic effects on the body.

Another example is an application to match the résumé of potentialcandidates with a job specification: in principle such an applicationwould need structured data to represent every skill that might be ofvalue to any role, every type of experience, every type of previous job.

Accounting is another application where vast heterogeneous data would bevaluable: the perfect accounting application would represent every typeof contract, every type of service.

In practice some of these applications, where they exist, work with alimited schema that doesn't cover the full range of their idealproperties. Health applications for example, typically work like thisignoring many types of data that they do not cover and instead end upbeing narrow—limiting the application to only certain verticals withinhealth.

Applications may also use natural language or augment a limited schemawith natural language—such as with current résumé matching applicationswhich might represent a few key skills in a structured form but relylargely on keyword searching or statistical natural language processing(NLP) techniques on written résumés otherwise.

In the case of accounting, transactions are represented with limitedstructured data—debits and credits on virtual ledgers with naturallanguage names. The meaning of the natural language names and thus whatthese transactions represent is generally opaque to the application.Virtual ledgers often group different types of transaction together butfail to represent semantic differences which may be important.

There is no exact threshold for when an application becomes a HUBapplication but the difficulty of building an application with a handcreated schema grows more than linearly with the number of tables asmanaging these tables as well as the code that maintains them becomesincreasingly difficult to do.

These issues could be addressed if there existed a language or way ofrepresenting data that computers could fully process and understand butthat also had an extremely broad scope.

In conventional Artificial Intelligence (AI), statistical MachineLearning (ML)—particularly Deep Learning (DL)—has been widely used. Thishas provided significant progress with many problems. Despite theprogress, the results cannot be explained in a way that makes sense tohuman users as the solutions are the result of a calculation that mayinvolve billions of weights. It can also be argued that the system lacks‘real’ understanding of the data or at least that the understanding isvery different from the way a human user would understand it.

3. Discussion of Related Art

The Wikipedia page about Cyc, of 18 Jul. 2019, states that Cyc is theworld's longest-lived artificial intelligence project, attempting toassemble a comprehensive ontology and knowledge base that spans thebasic concepts and “rules of thumb” about how the world works (thinkcommon sense knowledge but focusing more on things that rarely getwritten down or said, in contrast with facts one might find somewhere onthe internet or retrieve via a search engine or Wikipedia), with thegoal of enabling AI applications to perform human-like reasoning and beless “brittle” when confronted with novel situations that were notpreconceived.

The Wikipedia page about Cyc, of 18 Jul. 2019, states that the objectiveof the Cyc project was to codify, in machine-usable form, the millionsof pieces of knowledge that compose human common sense; this entailed,along the way, (1) developing an adequately expressive representationlanguage, CycL, (2) developing an ontology spanning all human conceptsdown to some appropriate level of detail, (3) developing a knowledgebase on that ontological framework, comprising all human knowledge aboutthose concepts down to some appropriate level of detail, and (4)developing an inference engine exponentially faster than those used inthen-conventional expert systems, to be able to infer the same types anddepth of conclusions that humans are capable of, given their knowledgeof the world.

The Wikipedia page about Cyc, of 18 Jul. 2019, states that most of Cyc'sknowledge, outside math and games, is only true by default; for example,Cyc knows that as a default parents love their children, when you'remade happy you smile, taking your first step is a big accomplishment,when someone you love has a big accomplishment that makes you happy, andonly adults have children; when asked whether a picture captioned“Someone watching his daughter take her first step” contains a smilingadult person, Cyc can logically infer that the answer is Yes, and “showits work” by presenting the step by step logical argument using thosefive pieces of knowledge from its knowledge base: these are formulatedin the language CycL, which is based on predicate calculus and has asyntax similar to that of the Lisp programming language.

The Wikipedia page about Cyc, of 18 Jul. 2019, states that the Cycproject has been described as “one of the most controversial endeavorsof the artificial intelligence history”; Catherine Havasi, CEO ofLuminoso, says that Cyc is the predecessor project to IBM's Watson;machine-learning scientist Pedro Domingos refers to the project as a“catastrophic failure” for several reasons, including the unendingamount of data required to produce any viable results and the inabilityfor Cyc to evolve on its own; Robin Hanson, a professor of economics atGeorge Mason University, gives a more balanced analysis: “Of course theCYC project is open to criticism on its many particular choices. Peoplehave complained about its logic-like and language-like representations,about its selection of prototypical cases to build from (e.g.,encyclopedia articles), about its focus on answering over acting, abouthow often it rebuilds vs. maintaining legacy systems, and about beingprivate vs. publishing everything. But any large project like this wouldproduce such disputes, and it is not obvious any of its choices havebeen seriously wrong. They had to start somewhere, and in my opinionthey have now collected a knowledge base with a truly spectacular size,scope, and integration. Other architectures may well work better, but ifknowing lots is anywhere near as important as Lenat thinks, I'd expectserious AI attempts to import CYC's knowledge, translating it into a newrepresentation. No other source has anywhere near CYC's size, scope, andintegration.”

The True Knowledge system provided open-domain question answering usingstructured knowledge and inference. In the True Knowledge system,knowledge in the knowledge base was represented in a single unifiedformat: named relations between pairs of named entities referred to as“facts.” Facts, and the relations themselves, were first-class entitiesso facts about facts and facts about the properties of relations werefully supported (Tunstall-Pedoe, W. (2010). True Knowledge: Open-DomainQuestion Answering Using Structured Knowledge and Inference. AIMagazine, 31(3), 80-92. https://doi.org/10.1609/aimag.v31i3.2298).

SUMMARY OF THE INVENTION

According to a first aspect of the invention, a computer implementedmethod for the automated analysis or use of data, comprises the stepsof:

-   -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language (‘machine representation’); the machine representation        including representations of user speech or text input to a        human/machine interface;    -   (b) automatically processing the machine representations to        analyse the user speech or text input.

In a second aspect, a computer-based system configured to analyse data,the system is configured to:

-   -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of user speech or text input to a        human/machine interface;    -   (b) automatically process the structured representations to        analyse the user speech or text input to a human/machine        interface.

These aspects of the invention may be implemented in a voice assistantor chatbot; the technical advantage achieved is to enable more extensiveand faster scaling of the voice assistant or chatbot's capabilities; theinvention enables voice assistants and chatbot to be able to answer abroader range of questions, and to do so more accurately; the inventionmakes it easier for the voice assistant or chatbot to work with largenumbers of different natural languages.

One point of interpretation: the conjunction ‘or’ should not be narrowlyconstrued to indicate mutual exclusivity but to cover inclusivity too.Hence, the phrase ‘user speech or text input’ means ‘user speech on itsown, or user text on its own, or both user speech and also user text’.When the conjunction ‘or’ is meant exclusively, the phrase ‘either . . .or’ is used.

The machine-readable language is extremely expressive yet also extremelysimple; simplicity requires less computer processing and thus deliversfaster performance. Further details of the invention are in the appendedClaims.

According to a further aspect of the invention, there is provided acomputer system including a processor and a memory, the processorconfigured to answer a question, the processor configured to use aprocessing language in which semantic nodes are represented in theprocessing language, the semantic nodes including semantic links betweensemantic nodes wherein the semantic links are themselves semantic nodes,in which each semantic node denotes one specific meaning, in which acombination of semantic nodes defines a semantic node, in whichexpressions in the processing language may be nested, in which thequestion is represented in the processing language, in which reasoningsteps are represented in the processing language to represent semanticsof the reasoning steps, in which computation units are represented inthe processing language, wherein the memory is configured to store therepresentations in the processing language, and wherein the processor isconfigured to answer the question using the reasoning steps, thecomputation units and the semantic nodes, and to store an answer to thequestion in the memory.

An advantage is that because semantic links between semantic nodes arethemselves semantic nodes, semantic links and semantic nodes do not needto be processed in a distinctly different way, which simplifiesprocessing, which speeds up response times, which is a technical effect.

An advantage is that because semantic nodes are very widely used in theprocessing language, processing of the processing language is speededup, which speeds up response times, which is a technical effect.

The technical effect operates at the level of the architecture of thecomputer system; that is to say the effect is produced irrespective ofthe data being processed.

The technical effect results in the computer system being made tooperate in a new way, because the computer finds answers to questionsfaster than using prior art approaches, because semantic nodes are verywidely used in the processing language, which means that processing ofthe processing language is speeded up.

The processing language contributes to the technical character of theinvention because it produces a technical effect: a processor processingthe processing language has the effect that the computer finds answersto questions faster than using prior art approaches, because semanticnodes are very widely used in the processing language, which means thatprocessing of the processing language is speeded up.

The computer system may be configured to output the answer to thequestion.

The computer system may be configured to output the answer to thequestion to a display device.

The computer system may be one wherein expressions in the processinglanguage may be nested with no limit inherent to the processinglanguage.

The computer system may be one wherein the semantic nodes each includesa unique identifier.

The computer system may be one wherein the computation units aresemantic nodes.

The computer system may be one wherein the question is represented inthe processing language with a passage comprising a semantic node thatidentifies the passage as a question, a list of zero, one or moresemantic nodes representing unknown entities being asked about and atleast one further passage which represents the semantics of the questionin the context of the zero, one or more unknown entities.

The computer system may be one wherein the processing language isuniversal language.

The computer system may be one wherein the processing language is not anatural language.

The computer system may be one wherein the question relates to searchand analysis of documents or web pages, wherein the sematic nodesinclude representations of at least parts of the documents or the webpages stored in a document store.

The computer system may be one wherein the question relates to alocation-based search, using mapping data represented as semantic nodesin the processing language.

The computer system may be one wherein the question relates to a searchfor defined advertisements or news, wherein the semantic nodes includerepresentations of advertisements, news articles or other informationitems.

The computer system may be one wherein the question relates to a requestfor a summary of a news topic, wherein the semantic nodes includerepresentations of news from multiple sources, e.g. to provide a summaryor aggregation of the news.

The computer system may be one wherein the question relates to a requestfor a compatibility match between persons, wherein the semantic nodesinclude representations of personal information defining one or moreattributes of a person, for a plurality of people.

The computer system may be one wherein the question relates tocompliance with requirements preventing abusive or illegal social mediapostings, wherein the semantic nodes include representations of socialmedia postings.

The computer system may be one wherein the question relates to analysingcustomer reviews, wherein the semantic nodes include representations ofcustomer reviews.

The computer system may be one wherein the question relates to a user'sproduct request, wherein the semantic nodes include representations ofproduct descriptions and user product requests.

The computer system may be one wherein the question relates to a jobsearch, wherein the semantic nodes include representations of jobdescriptions and job applicants' skills and experience, to determinewhich job applicants match a job description, or to determine which jobdescriptions match a job applicant's skills and experience.

The computer system may be one wherein the question relates to health ofan individual, wherein the sematic nodes include health data relating tothe individual, and health data relating to human beings.

The computer system may be one wherein the question relates tonutrition, wherein the sematic nodes include nutritional data for foodsand drinks.

The computer system may be one wherein the question relates toaccounting or finance, wherein the sematic nodes include representationsof financial or accounting information.

The computer system may be one wherein the question is received by avoice assistant or chatbot, wherein the semantic nodes includerepresentations of user speech input to a human/machine interface andinclude representations of the human/machine interface itself.

According to a further aspect of the invention, there is provided acomputer-implemented method, the method using a computer systemincluding a processor and a memory, the processor configured to use aprocessing language in which semantic nodes are represented in theprocessing language, the semantic nodes including semantic links betweensemantic nodes wherein the semantic links are themselves semantic nodes,in which each semantic node denotes one specific meaning, in which acombination of semantic nodes defines a semantic node, in whichexpressions in the processing language may be nested, in which thequestion is represented in the processing language, in which reasoningsteps are represented in the processing language to represent semanticsof the reasoning steps, in which computation units are represented inthe processing language, wherein the memory is configured to store therepresentations in the processing language, the method including thesteps of:

(i) the processor answering the question using the reasoning steps, thecomputation units and the semantic nodes, and

(ii) the processor storing an answer to the question in the memory.

Advantages include the advantages of the previous aspect of theinvention.

The method may be one wherein the question is represented in theprocessing language with a passage comprising a semantic node thatidentifies the passage as a question, a list of zero, one or moresemantic nodes representing unknown entities being asked about and atleast one further passage which represents the semantics of the questionin the context of the zero, one or more unknown entities.

The method may be one wherein the unknowns in the question areidentified and the passage making up the body of the question isselected for further analysis; processing begins on a list of passagesfrom the body of the question and the selected unknowns; a first passagein the list of passages is selected for processing; processing a singlepassage comprises three methods: using statically stored processinglanguage passages, utilising computation units and utilising processinglanguage generated from reasoning:

in which the first method is to lookup in the passage store if there areany passages that can be directly mapped with the passage beingprocessed; if the passage is exactly the same structure as a passage inthe passage store, with all nodes matching other than the unknowns, thenthe values the unknowns match against are valid results;

the second method is to check if any results can be found by executingcomputation units; it is checked if this passage matches against anypassages in a computation unit description; all non-unknown nodes in thepassage being processed must match the same nodes in the correspondingposition in the computation description or align with a computationinput unknown; the unknowns being processed must align to outputunknowns in the description; the computation unit is then called to getvalid output values for the processed passage's unknowns;

the third method is to see if this passage can be proved by applying anyreasoning steps; reasoning steps are searched for where a passage in thesecond half of the reasoning passage can be unified with the passagebeing processed; all nodes and structure must be equal between the twopassages, other than unknowns in the focus passage or the reasoningpassage; if a reasoning passage like this is found it means that thisreasoning step could be used to prove the passage being processed; amulti-stage process is used to first find any mappings for unknowns inthe processed passage when matching with the reasoning passage;secondly, mappings for unknowns used in the reasoning passage are foundby mapping with the passage being processed; this mapping can then beapplied to the front half of the reasoning passage to generate a list ofpassages that, if they can be matched with known or generated processinglanguage and mappings found for them, will prove and find valid mappingsfor the focus passage; solutions for the list of passages can then befound recursively.

The method may use a computer system of any aspect of the previousaspect of the invention.

Aspects of the invention may be combined.

BRIEF DESCRIPTION OF THE FIGURES

Aspects of the invention will now be described, by way of example(s),with reference to the following Figures, in which:

FIG. 1 shows example screen output for a notification of a job match.

FIG. 2 shows example screen output for a description of a job match.

FIG. 3 shows an example conversation within an app where nutritionaldata is being communicated with the app.

FIG. 4 shows some example insights that can be derived from a period oftime where horizontal health and nutrition data was shown.

FIG. 5 shows an example graph showing daily calories in versus caloriesout which is an extremely common thing for someone to track if the useris aiming to lose (or gain) weight.

FIG. 6 shows an example of a visualisation capable of being generatedfrom an example of the present invention: it is comparing estimatedcaffeine in the user's body at the time they went to bed with acalculation of sleep quality.

FIG. 7 shows examples of explanations generated. (a) shows examples ofsimplified explanations; (b) shows an example of a detailed explanation.

FIG. 8 shows an example of a voice assistant product, referred to hereinas ‘Brian’ and how it fits in with the wider UL platform and otherapplications built on the UL platform.

FIG. 9 shows an alternative to the example of FIG. 8 .

DETAILED DESCRIPTION

Examples of the present invention include systems and methods forcreating and using a structured representation of data that is aimed tobe as expressive as natural language in terms of breadth but which alsocan be processed and understood by automated systems. The representationreferred to herein as UL (for universal language) is a preferredexample. Examples of the invention include systems and methods relatingto specific HUB and other applications as well as systems and methodswhich process, store and utilize UL.

Use of UL also brings with it other advantages beyond the delivery ofHUB applications. For example, UL can be used as a way for an automatedsystem to understand the world and as a way for an automated system toreason. As the reasoning steps are recorded in language, such systemscan also fully explain themselves in language to human users.Requirements for a software system can be written in UL (referred toherein as ‘tenets’) and examples of the present invention can directlyuse these tenets to decide on actions for itself, rather than having itsdetailed actions determined by program code with a human programmertrying to anticipate all possible scenarios and code them in advance.

Representation of Language: UL

An aim of UL is in principle to be able to represent anythingexpressible in any natural language. An additional aim is for anythingexpressed in natural language to thus be translatable into UL. Thepurpose of UL is to enable use by machines so this representation ofdata must therefore be fully processable and understandable by automatedsystems. Although an aim, examples of the present invention may notfully deliver these aims whilst still having significant advantages overthe prior art.

There are many different properties of natural language that makegetting a computer to understand and process it extremely hard. Theseinclude polysemy—the fact that words in natural language often have manymeanings or senses, some related and overlapping and some completelydifferent and that context, years of experience with the naturallanguage and common sense knowledge is needed by people to understandwhich meaning is intended. For example, the English word “pen” can meana writing implement, an enclosure for farm animals, a female swan or aprison (short for “penitentiary”) among other meanings. As a verb italso has a number of related and different meanings. Despite thiscomplexity human beings can naturally infer the intended sense of theword using context, real world experience and common sense knowledgewhen it appears, but this is extremely hard for a machine, which lacksthe necessary skills.

Ambiguity and flexibility in the word ordering is another issue thatmakes natural language processing extremely hard for machines. Evensimple sentences can be phrased in literally dozens of ways which conveythe same meaning. Humans naturally understand these numerous phrasingsbut this is not easy to represent in an algorithm. Clauses and wordswithin a sentence modify and attach to other parts of the sentencechanging their meaning in ways that humans can naturally understand butwhich follow no clear rules that a machine can follow. Natural languagesalso use techniques like anaphora to refer back to entities referencedin earlier speech and avoid saying them again (e.g. in English withpronouns and words such as “he”, “hers”, “it”, “this” etc.). Humansnaturally understand what is being referred to but this is not soobvious for a machine. Ambiguity can even result from where theboundaries exist in a compound noun—for example the use of the compoundnoun “fruit flies” in the sentence “Fruit flies like a banana” comparedwith the sentence “Time flies like an arrow”.

UL is designed to overcome all these issues and create a language whichcan be parsed, understood and processed by a machine and which thus canstore an extremely broad range of information in a way that a machinecan understand, process and explain.

Semantic Nodes

A key component of UL is what we call herein a semantic node. A semanticnode is intended to be the broadest conceivable definition of a ‘thing’that can be defined—anything there is a word for can have a semanticnode in UL as well as things which have no natural language name.

In various examples, semantic nodes can include every specific humanbeing, the concept of human being (of which any specific human being isa member), every file, every web page, every audio recording or video,specific relationships (including the relationship that links anyspecific human being to the concept of human being), attributes,specific types of language nuance and every row and item in a relationaldatabase table.

A semantic node once defined has an identifier so it can be referred towithin UL. In a preferred example the ID is a 128-bit version 4 UUID(RFC 4122) with hyphenated lower-case syntax. For example:b1c1cb5f-248f-4871-a73f-900d29066948. A preferred example also allowsUnicode strings in double quotes to be their own ID— the string itselfis the ID for the semantic node for that specific string. For example,“Piña colada” is a valid semantic node representing only the string, notthe concept of the drink. In other examples, a UUID or other identifiercould be used for strings to simplify the syntax further, but requiringadditional language to express the link between the identifier and thestring it represents.

In an example, a simple grammar for UL is thus:

<passage> ::= <128 bit UUID> <passage>::= “<Unicode string>”<passage>::=(<passage> <passage>*)

Where <passage>* is zero, or more further <passage> and double quoteswithin the Unicode String are escaped \”

In an example, a semantic node may be represented by a 128 bit UUID or astring; a passage may be either (a) a semantic node or (b) two or moreother passages in brackets.

In another example, the minimum number of passages that can be groupedwithin parentheses is two so the third line of the above grammar wouldbe <passage>:=(<passage><passage><passage>*)

In a preferred example a given semantic node typically denotes onespecific thing or one specific meaning. Although polysemy is permissiblein a preferred example, with an essentially unlimited pool of UUIDsavailable there is no reason to overload a node with more than onemeaning and in practice all the possible senses of a word in a naturallanguage will be given different semantic nodes. Closely related sensesof a word can also be given different semantic nodes too and theirrelationship described with passages. This use of unique semantic nodesfor every possible sense overcomes the complexity and ambiguity fromdetermining sense in natural languages.

The use of semantic nodes also avoids any ambiguity that comes fromconcepts being denoted with multiple words in natural languages. In apreferred example, compound nouns, verb phrases, prepositional verbsetc. do not generally exist—each such concept has a single node andthere are no challenges for the machine in deciding where the boundariesof the representation lie.

Node Agreement

Herein we use the term “user” to mean any human, organisation or machineuser of an example of the present invention. A user could be anycomputer system that uses an example of the invention or any human beingor organisation that makes use of UL. It can also be subsystems oflarger computer systems.

In a preferred example if two semantic node identifiers are different,they may or may not be the same concept—as two different users of theinvention may have chosen two different IDs for the same thing. If twoidentifiers are the same, by design in a preferred example they mustdenote the same things, defined in the same way. Thus, UL becomes usefulfor communication when agreement happens on semantic nodes and these areadopted across different systems. UL may become understandable to humanusers when enough is known about semantic nodes to be able to expressthem in natural language and generate natural language that has similarmeaning to the UL.

In a preferred example, the meaning of a semantic node comes only fromother UL that represents things that have been said about the node.Sometimes this may represent the UL expressed knowledge that thesemantic node corresponds exactly to a word or sense of a word in anamed natural language. For example, the Spanish drink Sangria may berepresented as a6ba9f28-b54d-4e4a-8cf8-ad4e07659004. Pen in the sense ofa writing implement may be represented asc092849c-80ed-4a69-9a4e-2704780f0cea but the concept of a pen in thesense of an enclosure for farm animals would have a completely differentnode such as ba9b43a3-540d-44ff-b6fe-62dcfb9dda1c. Although thesemeanings may be documented somewhere for human users, passages of ULwould define and semantically link these concepts to other conceptsgiving them meaning. For example in the case of the Sangria concept,passages may assert that it is kind of drink, that is alcoholic, that itoriginates in Spain. Passages may further define the ingredients orother information relevant to the machine understanding of what it is.

As used herein a “shared ID” is an ID used by more than one user ofvarious examples of the invention. Typically, one user has created andused the ID and a second, or more users, has decided that this IDrepresents a concept they also want to use and has then started using ittoo. A “private ID” or “local ID” is similarly an ID used by only oneuser and is not published or exposed to other users. A “public ID” is anID that a user has used in UL that can be seen by every user, whether itis shared or not depends on whether any other client entity has startedusing it. According to various examples, IDs can be shared betweenmultiple users without being made fully public.

To express this in other words, any user of an example of the presentinvention can coin their own semantic nodes with their own local meaningby picking an unused identifier. For example, an application couldassign a semantic ID to the rows of a particular local database table.Any number of different IDs can represent the same thing. When semanticnodes are shared, however, their meaning is shared. If another user wereto then use those IDs elsewhere, they would mean the same thing anddenote the same thing. In a preferred example with a 128-bit addressspace, selecting an ID randomly from that space has an essentially zeroprobability of a collision if one was not intended, enabling local IDsto be coined and used without having to undergo any kind of registrationprocess or communication or coordination with any other user. In anotherexample string identifiers could be used and users could include aunique substring in their own local identifiers using it e.g. as aprefix. For example, an organisation may choose a unique prefix like“unlikelyai719” and then name all its nodes starting with this e.g.“unlikelyai781_sangria”—with a unique prefix it can ensure that itslocal ids are not duplicated by any other user. Other examples may use asmaller address space and have a more centralised approach possiblyincluding registration.

Strings

As previously mentioned, in a preferred example, Unicode strings alsorepresent semantic nodes. Their meaning is strictly the string itselfonly. Any natural language meaning contained within the string is notpart of the meaning of these IDs. i.e. “sangria” means strictly thesequence of letters s..a..n..g..r..i..a—not the concept of the drink.Following the principle of node agreement discussed above it is alsopossible for a string to be represented by an ID as an additionalidentifier. For example, the string “sangria” could be additionallyrepresented as fc570fba-cb95-4214-bc45-8deb52d830a5 and this representedin a passage or otherwise. This can be used for very large strings.Following the same design principle, two identical strings used assemantic nodes have universal meaning as that string.

Combination Nodes

Combining semantic nodes also defines a semantic node. Shared rulesaround the meaning of shared nodes or shared classes to which nodesbelong define further shared meaning from the combination. For example,semantic nodes within an infinite class can be represented by combiningone or more nodes that define the class with one or more strings wherethere is a common internationally recognised representation in stringform. e.g. integers can be defined this way. (<id for integer>“5”).Another example of a combination node with more than two nodes within itis (<id for group><id for Chicago><id for New York City><id for London>)which is a single semantic node representing a collection of threecities regarded as a single entity. Combination nodes can contain anyfinite number of semantic nodes and the semantic nodes within them canalso be combination nodes creating any level of nesting.

Nesting

UL syntax allows for expressions to be nested indefinitely. This allowsthe user to define a concept, coupled with contextual information aboutthe concept, as a hierarchy of UL expressions under the same parent ULexpression or with the same central expression or passage. Context canbe used to provide nuance, source, belief, temporal validity etc. Forexample, starting with a passage (HoldsOffice JoeBiden UsPresident)(where HoldsOffice JoeBiden and UsPresident are human readable“nicknames” for IDs—described further below) another passage that stateswhen it is true could be (HasTemporalValidity (HoldsOffice GeorgeWBushUsPresident) (DatelsoFormat “2021-07-23”))—which says that Joe Bidenheld the office of US President on the 23^(rd) of July 2021. Furtherexpressions around this passage could assert that this statement hadcome from a particular source or had a certain degree of reliabilityetc.

Combination Agreement

In a similar way to the principle of node agreement where use of thesame semantic node by the same or different entities implies identicalmeaning between usages, the meaning that comes from combining sharedsemantic nodes is also universal. Any client entity that chooses tocreate passages that use shared semantic nodes is also expressing thesame meaning by combining them. Similarly, any client entity is free todefine its own meaning to combinations of semantic nodes that are notused elsewhere.

In other words, further meaning comes from combining semantic nodes.Again, if semantic nodes are shared then the meaning that comes fromcombining them is also shared. In a preferred example, semantic nodescan be combined in any numbers and at any level of nesting and nofurther syntax is required. Other examples may include additionalsyntax. The combining and nesting herein and in a preferred example isdone with round brackets when UL is displayed. However, various examplesand implementations of examples may represent the combining of nodes inother ways. For example, the syntax could group nodes with differentcharacters than round parentheses, there could be special function wordssuch as “query” in the syntax that are not semantic nodes but whichdefine different types of passage or there could be special syntax forcertain types of node such as unknown values or booleans or integers.

The combinations in UL in a preferred example are expressed directlywith brackets. There is no ambiguity in how the nodes are grouped or anyassumed grouping when brackets are absent. This syntax thus avoids theambiguity that is extremely common in natural languages where clausesand words group and modify other parts of a sentence in ways that areextremely hard for a machine to determine. For example, the Englishsentence “The police arrested the demonstrators because they fearedviolence” is ambiguous about whether “they feared violence” applies tothe demonstrators or the police. Natural language has no rigorousgrouping syntax meaning that this type of ambiguity is common. Humanbeings armed with considerable experience of the world can infer fromcommon sense and their world knowledge that it is more likely to applypolice in this case. Unambiguous grouping in UL ensures that a machinecan always get it right.

UL syntax

A UL expression is either a semantic node or a passage. Both variationsare atomic, complete pieces of valid UL. Semantic nodes are definedfully above, and include either a UUID or a Unicode string. A passage isany combination of nodes, and it is the sole nesting construct of UL.Passages may be anything from a single semantic node to a complexhierarchy representing an entire book.

A simple, more formal, grammar for UL in the preferred example couldthus be:

universal_language  = ul_element*  | EOF ul_element  = semantic_node  |passage semantic_node  = version_4_uuid  | string_literal passage = ‘(‘ul_element+ ’)’

The above grammar uses the symbols (and) to denote grouping, and omitsimplementation-specific details such as character escapes within stringliteral nodes.

Various examples of this invention may extend or change the abovegrammar to suit their needs. Possible extensions include additionalsyntax for specific types of node: for example, integers, real numbers,points in time, unknowns. Possible other extensions include comments,ignored by any UL parser, and “named passages”. Named passages couldrepresent a way to link passages to a nickname in a human-readablelanguage, such as English. Nicknames are further described in thefollowing section.

Note that a preferred example uses this extremely simple syntax withoutextension and there is no special additional syntax for different typesof passage—meaning comes purely from the choice of semantic nodes andhow they are grouped both in terms of grouping and ordering. Being ableto express everything with such a simple representation has significantadvantages over alternatives which use more complicated syntax or usespecial additional syntax for particular things. These advantagesinclude the simplicity and generality of implementation which can resultin significant speed improvements when processing the language. It alsogreatly simplifies the storage of UL and the ability to search andprocess it. With more complicated syntax, different code needs to handleeach of the different types of syntax. Storage is greatly complicatedtoo. The more complicated storage also adds to the complexity of thecode that needs to access it and the speed it can be accessed.

Nicknames

To make UL more understandable to humans, various examples have a‘nickname’ scheme where shorter natural language labels are associatedwith a UL expression and those names are used when presenting UL tohumans. These labels may be used as alternatives to raw UUIDs whendisplaying UL to humans. In a preferred example, any number of nicknameschemes can be defined, enabling users familiar with different naturallanguages to access meaning in UL. The example nickname scheme usedherein is termed English1. In some examples (but not a preferredexample) these nicknames may be used as the identifier. In a preferredexample, these nicknames are not identifiers but merely a way ofpresenting identifiers to humans.

As an example of UL representation, this is a valid passage:

(03d206a2-52ca-49e1-9aeb-86364e2dead6cb75d6f8-16d9-4a36-8c16-7195182d4057(d1fd5662-c88e-4d94-b807-5310483df8cd(30847a3d-e43c-4229-993e-20ad01adc1265a533842-bcd8-4125-8b39-2b1caa643593)))

The meaning of this passage corresponds to the English “Brie is acreamy, French cheese”.

Assigning these nicknames to the semantic nodes within this passage likeso:

IsA=03d206a2-52ca-49e1-9aeb-86364e2dead6

Brie=cb75d6f8-16d9-4a36-8c16-7195182d4057

Cheese=d1fd5662-c88e-4d94-b807-5310483df8cd

Creamy=30847a3d-e43c-4229-993e-20ad01adc126

French=5a533842-bcd8-4125-8b39-2b1caa643593

means the above passage can be displayed in a more human readable formthus:

(IsA Brie (Cheese (Creamy French)))

Creamy and Cheese are semantic nodes that are properties or attributesof other semantic nodes. This concept (given the nickname Attribute) isa semantic node that corresponds to a class of such nodes and is shared.Part of the shared meaning in a preferred example is that two or moreattributes combined make a new attribute where all the constituentattributes apply so (Creamy French) is itself an attribute meaning inEnglish “creamy and French”.

Cheese is a class meaning things which are cheeses. Another sharedmeaning from Class and Property is that combining a class with aproperty gives the class of all things in that class which have thatproperty so (Cheese (Creamy French)) is the class of all creamy, Frenchcheeses—“creamy, French cheese” in English.

IsA is a semantic node which has shared meaning from combining asemantic node with a class meaning the node is a member of that class so(IsA Brie (Cheese (Creamy French))) can be translated to English with“Brie is a creamy, French cheese”.

Again, in a preferred example, the choice of English1 nickname is chosento be helpful by choosing a name that corresponds to English languagethat approximates the meaning of the node. However, the meaning of thenode only comes from its usage in the system.

Negation

To say something is not true the semantic node Not in combination withanother relationship node defines a relationship node which is truewhenever the original relationship is false. e.g.

((Not IsA) Bat Bird)

is a true statement.

Questions

Questions can be represented in UL by combining a node that identifiesthe passage as a question with a list of zero or more unknowns and afurther passage or passages which represent the semantics of thequestion using the zero or more unknowns. In a preferred example, thepassage of UL is of the form ((Question <unknowns>)(<passage>)) whereQuestion is a semantic node and <unknowns> is a list of zero, one ormore semantic nodes representing unknown values (similar in meaning toletters of the alphabet in algebra) and where <passage> is where theunknowns are used to express what is being asked about. In a preferredexample, these unknowns are simply semantic nodes, members of the classUnknown—other than their meaning they have no special status. Herein weuse Unknown1, Unknown2, X etc. as nicknames for members of this class.Note that questions in a preferred example are UL passages like anyother: the syntax of UL has not been extended or changed in any way tosupport questions.

e.g.

(Question Unknown1)((HasAttribute Unknown1 Alcoholic) (IsA Unknown1Drink))

translates into English as “What drinks are alcoholic?” or “Listalcoholic drinks”)

Yes/No questions have zero unknowns so both

((Question)((IsA Sangria Drink)(HasAttribute Sangria Spanish)))

((Question)((IsA Sangria (Drink Spanish))))

translate as “Is Sangria a Spanish drink?”

Another example is:

((Question) (WithinRange (Integer “7”) (AtLeast (Integer “5”))))

which is asking “Is 7 within the range ‘at least 5’?” The questionpassage is made up of a head passage—in this case just (Question)—and atail of other passages—in this case just (WithinRange (Integer “7”)(AtLeast (Integer “5”))). The head part's first element will always bethe Question node, followed by any number of unknowns that can be usedto signify the outputs of the question if it is not a simple yes or noquestion. Only the unknowns used for outputs need to be specified here.Unknowns are just semantic nodes in the class Unknown.

An example question that uses unknowns (to be mapped to the outputs) is:

((Question Unknown1) (IsA Unknown1 (Cheese Creamy)))

Which is asking “What are the creamy cheeses?”/“List creamy cheeses?”The unknown Unknown1 is used in the question and any nodes that can becorrectly mapped to Unknown1 from other things represented in UL arereturned as appropriate outputs for the question.

An example of a UL question that would give No as an answer is:

((Question) (HasAttribute Cheddar Creamy))

Which is asking “Is cheddar creamy?”. In examples where it is known thatA. Cheddar is a hard cheese and B. that hard cheeses are not creamy thesystem can prove that cheddar is not creamy and will return a ‘No’result.

Reasoning

Reasoning is where UL is generated from other UL. A reasoning passage isa bit of UL that represents how new UL can be generated from otherUL—for example a logical consequence or giving meaning to other nodes ora combination of nodes. e.g. the English “if something originates fromFrance then it is French” translates to a reasoning passage in UL.

Reasoning steps are represented as passages which represent thesemantics of the step. Note that in a preferred example reasoningpassages are represented in UL like anything else.

There is no special syntax or content that extends or changes UL tosupport reasoning. For example:

(ConsequenceOf (IsA X (Cheese Hard)) ((Not HasAttribute) X Creamy))

Which says that “If X is a hard cheese then X is not creamy.” In thepreferred example, these reasoning steps begin with a ConsequenceOfsemantic node. This is then followed by a passage which represents theconditions that need to hold for this step to be used (the ‘if’passage). This can be just one passage like in this example, or it canbe a passage that contains other passages which would all need to hold.The third element is a passage that is true if the conditions are met(the ‘then’ passage). This can also be a passage of passages, in whichcase all of the passages contained would be true if the conditions aremet.

Some more examples of reasoning steps:

(ConsequenceOf (IsIn X Y) (IsA Y GeographicalArea)) in English is “If Xis in Y then Y is a location” (IsIn represents geographical location)

(ConsequenceOf (IsA X Continent)) ((IsIn X Earth)) in English means “IfX is a continent then X is in Earth”

Computation Units

Computation units are a way of allowing examples of the presentinvention to represent and make use of computation required forreasoning and other purposes. Any automatic process that calculatessomething or returns a result can be supported with this technique.Various examples also allow them to support actions such as completing atransaction, turning on a light, playing music etc.

As a simple example, according to various examples a computation unitmight allow UL to answer questions such as “Is 7 greater than 5?”Clearly explicitly having to enter the passages for every combination oftwo integers would be impractical. In a preferred example, thecomputation unit can be thought of as a semantic node which is anexample of the class ComputationUnit. We can then add passages thatrepresents details for this unit needed to select and run it: what itcan do, how to run it and how to interpret the results.

For example, here is an example computation unit for addition:

(ComputationLocalJavaLocation AdditionComputationUnit“ai.unlikely.questionprocessor.computation.Arithmetic$Addition”)

(ComputationInputs AdditionComputationUnit InputOne InputTwo)(ComputationDescription AdditionComputationUnit ((Question Unknown1)((Equal (RealNumber Unknown1) (Add (RealNumber InputOne) (RealNumberInputTwo)))))) (ComputationDescription AdditionComputationUnit((Question Unknown1) ((Equal (Add (RealNumber InputOne) (RealNumberInputTwo)) (RealNumber Unknown1)))))

In this case there are two passages which describe the computation unit.Description passages have a head node, ComputationDescription, followedby the node for the unit they are describing, and then a passage for theclass of UL questions they can help to answer. We also have a passagefor the computation unit that describes its inputs, in this case we aresaying that the function to compute addition requires two inputs. Thedescription passage uses these inputs to describe where they appear inthe question. The final passage we need for the computation unit to workis one that gives the location. In this case, we useComputationLocalJavaLocation at the head of the passage which means thatwe are describing a Java class that is locally available to the questionprocessor to use at runtime. With all this information, the system canrealise when computation is needed and lookup the best way to get ananswer for it and compute it. A preferred example represents many waysto invoke computation units. Each method can be described with a passagesimilar to this one but with a new head node and a different way todescribe the location and way to invoke the computation. For example, ifwe were to add a computation engine that utilises Lua scripts we couldadd a passage such as:

(ComputationLuaScript AdditionComputationUnit“a,b=io.read(‘*n’,‘*n’)\nio.write(a+b)”)

to help the engine to compute the unit in this way. Another example isthe use of an API endpoint and specifying a URL that will return theresult with a GET request.

Other examples of computation units are described here to furtherillustrate the concept:

(IsA GreaterThanOrEqualComputationUnit ComputationUnit)

(ComputationLocalJavaLocation GreaterThanOrEqualComputationUnit“ai.unlikely.questionprocessor.computation.Comparison$GreaterThanOrEqual”)

(ComputationInputs GreaterThanOrEqualComputationUnit InputOne InputTwo)(ComputationDescription GreaterThanOrEqualComputationUnit ((Question)((GreaterThanOrEqual (RealNumber InputOne) (RealNumber InputTwo))))) forgreater than or equal comparisons and:

(IsA EqualComputationUnit ComputationUnit)

(ComputationLocalJavaLocation EqualComputationUnit“ai.unlikely.questionprocessor.computation.Comparison$Equal”)

(ComputationInputs EqualComputationUnit InputOne InputTwo)(ComputationDescription EqualComputationUnit ((Question) ((Equal(RealNumber InputOne) (RealNumber InputTwo)))))

for equality comparisons on real numbers.

Validating that UL is Meaningful/Validation Passages

Just as it is possible to write words in a natural language which haveno meaning (such as nonsense verse) it is possible to writesyntactically correct UL in a way that is not meaningful. According tovarious examples it is possible to define clear rules which identifymeaningful and non-meaningful UL syntax and for these rules to beapplied automatically to determine invalid passages. Note thatinvalidity is different from truth. A passage can be valid yet stillrepresent something which is untrue.

For example the IsA semantic node that was described earlier requirestwo additional nodes in order to form a passage where the second nodehas to represent a class to be meaningful. (IsA Brie GatwickAirport) forexample is not meaningful as GatwickAirport is not a class (this passagewould translate into English as “Brie is a Gatwick Airport”. (IsA BrieCheese OriginatesFrom) is also not meaningful as IsA is followed bythree nodes instead of two.

Validation can be done by any machine-readable description of theseconstraints which can be read and checked automatically. In a preferredexample these are naturally done with other UL passages that describethese constraints called Validation Passages herein. Typically theseconstraints would be provided by the business, organisation or personthat defined the key node in the passage. When validating a passage,examples of the present invention can look at each passage andsub-passage and search for validation passages that apply based on thesemantic nodes in these passages. By checking these validation rulesagainst the examined passage a view can be determined as to whether thepassage is invalid.

An example of a validation passage on the node IsA is (Validation (IsAUnknown1 Unknown2) (IsA Unknown2 Class)) which says that given a passagein the form (IsA <node1><node2>), (Question)(IsA <node2>Class) shouldreturn Yes (or not return No). If it returns No, the passage is invalid.To constrain the number of nodes that can follow a named node a passagelike (ValidationCount IsA (Integer “2”)) says that IsA nodes must haveexactly two semantic nodes following them to be meaningful. Variationsof these examples can define further constraints on meaningful passages.In another example, (HasSchema ExpressedInEnglish (SchemaExpressedInEnglish Node String)) is an alternative way of expressingthat ExpressedInEnglish passages expect two additional nodes, the firstin the class Node (any node) and the second in the class String.

Validation can be used to check or select valid UL that has beengenerated during statistical methods of translation that may not alwaysgenerate valid UL (as described herein) and to check UL that has beenentered by humans. It can also be used to find contradictions or otherlogical inconsistencies in passages. For example, using a passage thatasserted that another relation had similar or related semantics to IsAmight be in conflict with validation passages that described differentexpectations of the semantic nodes that can be grouped with thisrelation.

UL Variations

Many variations on the definition of UL are possible for those skilledin the relevant art. Variations can include choice of syntax, choice ofrepresentation and selection of many of the other details of therepresentation and implementation. As used herein and where appropriate‘UL’ is intended to cover not only a preferred example described hereinbut all these similar UL-like representations and variations.

Methods for Answering Questions

In a preferred example the unknowns in the question are identified andthe passage making up the body of the question is selected for furtheranalysis. The nodes following the Question node in the head of thequestion passage are the unknowns that we are trying to find mappingsfor, such that they satisfy the body of the question. Successfullysatisfying the body with UL which is believed to be true is the path toanswering the question.

In an example, processing begins on the list of passages from the bodyof the question and the selected unknowns. The first passage in the listis selected for processing. This processing aims to find all possiblemappings for the unknowns that can be true for the passage selected.

In an example, processing a single passage comprises three methods usingstatically stored UL passages, utilising computation units and utilisingUL generated from reasoning:

The first method is to lookup in the passage store if there are anypassages that can be directly mapped with the passage being processed.If the passage is exactly the same structure as a passage in the passagestore, with all nodes matching other than the unknowns, then the valuesthe unknowns match against are valid results.

The second method is to check if any results can be found by executingcomputation units. We check if this passage matches against any passagesin a computation unit description. All non-unknown nodes in the passagebeing processed must match the same nodes in the corresponding positionin the computation description or align with a computation inputunknown. The unknowns being processed must align to output unknowns inthe description. The computation unit can then be called to get validoutput values for the processed passage's unknowns.

The third method is to see if this passage can be proved by applying anyreasoning steps. We look for any reasoning steps where a passage in thesecond half of the reasoning passage can be unified with the passagebeing processed. All nodes and structure must be equal between the twopassages, other than unknowns in the focus passage or the reasoningpassage. If a reasoning passage like this is found it means that thisreasoning step could be used to prove the passage being processed. Amulti-stage process is used to first find any mappings for unknowns inthe processed passage when matching with the reasoning passage.Secondly, mappings for unknowns used in the reasoning passage are foundby mapping with the passage being processed. This mapping can then beapplied to the front half of the reasoning passage to generate a list ofpassages that, if they can be matched with known or generated UL andmappings found for them, will prove and find valid mappings for thefocus passage. Solutions for this list of passages can then be foundrecursively using the methods we are currently describing. In someexamples we track the reasoning depth currently being processed (i.e.the number of reasoning passages applied) and impose a maximum depthlimit to how far we explore for latency reasons.

These three methods may happen in any order and are not dependent oneach other.

When a list of valid mappings has been found for the first passage inthe list, we must then look at the rest of the list. If the listcontains only one passage then the mappings returned are all valid.Otherwise, we look at each solution returned and apply it to theremainder of the list before it is processed. This will return a set ofmappings that can then be combined with the mappings given for the headto give a final complete mapping.

Some questions are Yes/No questions and have no unknowns that we aretrying to find mappings for. These questions are processed slightlydifferently. Initially they are processed in the same way in order tosee if we have passages, reasoning steps or computation units that canprove the question passage to be true. If this returns a successfulresult, we can return a Yes result. If no successful result is returned,we look at all passages in the question and negate them using the Notnode. Each of these negated passages is then processed to see if we canprove the negative of the original question. If one of these returns asuccessful result, then a No result can be returned. If none of theinitial processing or negated passages processing returns a successfulresult, that means we cannot show if a question is either true or false.Therefore, we can only return a DontKnow result.

Question Processing Example:

To further explain this process, the following is a walk-through of howthis method achieves a result for a simple example. For this example,all nicknames used are valid and the relevant UL passages stored arethese which exist within a trusted UL store believed to only containtrue factual statements:

(IsA X Unknown)

(IsA A Unknown)

(IsA B Unknown)

(IsA Cheddar Cheese)

(IsA Brie Cheese)

(OriginatesFrom Brie France)

(ConsequenceOf (OriginatesFrom X France) (HasAttribute X French))

(ConsequenceOf ((IsA X A)(HasAttribute X B)) (IsA X (A B)))

The question is ((Question X) (IsA X (Cheese French)))

This translates to English as “List French cheeses”.

X is identified as an unknown which needs a mapping and the passages toprocess is the list (shown here within square brackets) [(IsA X (CheeseFrench))]. From now we will show this as [(IsA X (Cheese French))]−X

(IsA X (Cheese French))−X is processed. It cannot be matched directlywith any passages or match any computation units. However, it might beproved by the reasoning passage

(ConsequenceOf ((IsA X A)(HasAttribute X B)) (IsA X (A B))) as itmatches with the second half. The mapping is applied and processingcontinues e.g. recursively.

[(IsA X Cheese), (HasAttribute X French)]−X is processed. The firstpassage is selected.

(IsA X Cheese)−X is processed. It can be matched with two passages togive the mappings X→Brie, X→Cheddar. No computation units or reasoningpassages can be applied.

These mappings are then applied to the rest of the list in turn. Thiscauses the following passages to be processed:

(HasAttribute Brie French)—Only the reasoning passage (ConsequenceOf(OriginatesFrom X France) (HasAttribute X French)) can be applied

(OriginatesFrom Brie France) This completely matches with a trustedpassage in the passage store, so we know that this is true. Therefore,(HasAttribute Brie French) is also true.

This combines with the mapping the level above to give X→Brie as a validresult.

Then:

(HasAttribute Cheddar French)—Only the reasoning passage (ConsequenceOf(OriginatesFrom X France) (HasAttribute X French)) can be applied

(OriginatesFrom Cheddar France) This cannot be proved by any means.Therefore, (HasAttribute Cheddar French) cannot be proved.

This therefore results in no result.

The complete process thus gives a single valid mapping of X→Brie, whichin turn gives Brie as a final answer.

In various examples, the steps that answer the question are recorded toprovide an explanation. The raw output from an example that does this,for this question is here:

Outcome: Yes

Solution: X→Brie

Explanation:

(IsA Brie (Cheese French))

Known: (IsA Brie Cheese)

(HasAttribute Brie French)

Known: (OriginatesFrom Brie France)

The approach outlined above for processing questions may also be used tosolve crossword clues, in contrast to conventional AI which isunsuitable for this task. For example, “Creamy French cheese” could be acrossword clue and the approach described above enables the solving ofthat crossword clue or the definition part of cryptic crossword clues;the clue could generate the answer “Brie”.

The approach outlined above is the general process used in some examplesfor processing questions, however further examples have improvementsthat can be made to this system for the benefit of reducing latency.

One of these improvements is that an in-memory “dynamic programming”cache can be used to store the resulting mapping of any passage withunknowns that is calculated during the processing of a question. Due tothe nature of the question processing, exploring different branches ofreasoning can lead to the same passage, and pattern of unknowns, beingprocessed. This cache means that each of these sub questions only needsto be processed once, with subsequent attempts returning the mappingsstored in the cache.

A purely recursive approach means that all data fetching from ourdatabase systems must happen sequentially just before that data isneeded, with all further processing having to wait. To reduce thisbottleneck, the system can be modified into two ways. Thesemodifications allows as much data fetching and processing to happenasynchronously and in parallel as possible before a final processingstep explores the data and builds the results.

When looking at a passage with unknowns, the three stages outlined above(matching with passages in the store, fetching and execution ofcomputation units and fetching reasoning passages) can be processed inparallel, with data fetching being done asynchronously so that theprocessing thread is not blocked. The reasoning passage step will thenreturn other passages with unknowns that need to be processed, theresults of which can be used to give results for the initial passage.This tree of connection can be stored and the processing of these subquestions that occur from reasoning can happen in parallel, allowingdata fetching and exploration of reasoning to be parallelized.

Once all passages are processed up to the given maximum reasoning depth,a second non parallelised step can be used to walk through this tree ofprocessed passages and unknown mappings to find valid answers. Whenlooking at a list of passages, where each passage now has its validmappings from the passage store and computation, a valid mapping forthat list is one where all unknowns have a value and there are nocontradicting mappings between passages in the list. This step canrecursively look through the data and find all valid mappings for theinitial question which can be returned as the answer.

Various examples may selectively store at least some of the passagesthat have been generated from reasoning or computation making theseavailable in the future for faster processing. The history of thesegenerated passages is also stored in various examples so that changes tothe trust in the passages that were used to generate them can beextended to the trust given to these new generated passages.

Priority Queue Example

An alternative example to the recursive system outlined above is toutilise a priority queue to control the order that sub queries areprocessed in. This alternative uses the same three steps for processinga given query passage but differs in the way that these passages areselected for processing and the way that sub queries are stored. Allquery passages uncovered during processing are stored with any solutionsdiscovered for that query in a map. This data can then be looked up bythe shape of the query passage. The shape of a query passage is definedsuch that all unknowns are treated as equal, so that the queries (IsA XCheese) and (IsA Y Cheese) are considered to have the same query shapeand be the same sub query.

Alongside this map we also maintain an ordered priority queue of the subqueries left to process. Query passages that we wish to process arefirst run through our prioritisation method, outlined below, tocalculate a priority value for that sub query. They are then placed onthe priority queue such that the subqueries with the highest prioritiesare at the front of the queue. Initially the only query passages addedto the map and priority queue are the passage in the body of theincoming question. Processing begins by taking the highest priorityquery from the queue and processing following the three steps outlinedabove.

The third step of processing a sub query will output new reasoning stepsbased on the reasoning passage in the data, which can be used to findsolutions for the query. For example, the sub query (IsA X (CheeseCreamy)) and the reasoning passage (ConsequenceOf ((IsA XY)(HasAttribute X Z)) (IsA X (Y Z))) can lead to the reasoning step:

if passages: (IsA X Cheese) (HasAttribute X Creamy)

then passage: (IsA X (Cheese Creamy))

These reasoning steps are stored so that, when combined with the querymap the reasoning tree for a question can be explored. The if passagesgenerated from this new reasoning step can then be added to the querymap (if not already present) as well as be prioritised and added to thepriority queue for processing.

With this example, when new solutions for a sub query are found duringprocessing they are added to the data in the query map. When this occurswe also look at the stored reasoning steps to see if any solutions canbe propagated towards the root of the reasoning tree. For example, if wealready know that X has the solutions {Brie} for the query (IsA XCheese), and we discover the solutions X={Brie, MashedPotato} whileprocessing the query (HasAttribute X Creamy) we can look back at thereasoning step above. If we can find a value for X which satisfies bothif passages, then we know it is a solution for the then passage. In thisexample, the solution X=Brie is a solution for both if passages, so itcan be added to the solutions for the then passage, (IsA X (CheeseCreamy)), in the query map.

Optimisations

It is possible to place limits on how much work is done processing aquestion in order to control latency by limiting the number of subqueries that are processed. This can be done as well as or instead of adepth limit.

This example allows for flexible parallelisation of query processing.Rather than processing one query from the queue at a time, the systemcan use multiple threads to process multiple queries simultaneously.Each thread can independently remove the next query to process from thequeue, process it, prioritise any resulting sub queries and insert theminto the queue. The thread can then take the next query to process fromthe queue.

Prioritisation Method:

Multiple methods of query prioritisation are possible, the simplestbeing to prioritise queries based on their depth within the search tree.The depth value of a query passage increases by one for each reasoningstep it is away for the initial question. Using this prioritisationcauses the system to follow a breadth first search pattern, processingall queries at a given depth before looking at those the next step downthe tree.

Alternative examples can take into account a number of factors includingthe depth, the reasoning passage used to create the reasoning step, theposition of this passage within the reasoning step, and any solutionsalready discovered for the parent passage or sibling if passages withinthe reasoning step. This can allow for a “best first” exploration of thesearch space, with the goal of exploring areas most likely to providesolutions as soon as possible. This is beneficial as it can lead tofaster processing of yes/no questions and improved processing abilitywhen constrained by a query processing limit.

With this prioritisation scheme the priorities of queries might changedue to solutions found elsewhere in the reasoning tree. Therefore whennew solutions are discovered and added to the query map, we must triggera reprioritisation of all children of the query in question by lookingat the reasoning steps uncovered by the “then passage” (the passage thatdescribes the consequence of the reasoning step).

Complex Reasoning Steps:

Some queries can result in sub queries which contain more than oneunknown, for example (IsA X Y). These queries can return many solutions,depending on the data, and can result in slow processing times. We callreasoning steps which contain these types of queries complex reasoningsteps. To overcome this issue we use an optimisation for complexreasoning steps where initially only the if passages containing oneunknown are processed. Any solutions found for this unknown can then besubstituted into the complex reasoning step to create simple reasoningsteps, with one unknown, which can be processed as normal.

For example, take the query (IsA X Food) and the reasoning passage(ConsequenceOf ((IsA X Y)(IsSubclassOf Y Z)) (IsA X Z)).

This results in the complex reasoning step:

if passages: (IsA X Y) (IsSubclassOf Y Food)

then passage: (IsA X Food)

The first passage contains more than one unknown so is not added to thepriority queue for processing, however the second if passage can beprocessed. When this second passage is processed we may find thesolutions for X of {Cheese, Nut}. The solutions are substituted into thereasoning step to create new simple reasoning steps. Here we use theresult Cheese as an example but this can be done with all solutions forX.

if passages: (IsA X Cheese)

then passage: (IsA X Food)

We can now treat this new reasoning step as normal and prioritise andprocess the query passage (IsA X Cheese).

Thinking Results

Question answering in various examples has already been described. Somequestions can potentially require significant reasoning effort to answerand various examples may choose to limit the amount of reasoning donefor specific applications in order to return results within a reasonabletime. This can be done, for example, by limiting the number ofsubqueries performed for a particular question.

When answering questions, the same question may be asked again in thefuture, and various examples may choose to store the results of queriesso that the same question can be answered more quickly next time.Various examples may also extend this approach to subqueries—saving theresults to questions that the question processor is asking duringreasoning.

In an example, it may be chosen to save these results during responsesto user questions or to save them only during an offline process wheredeep processing of questions can take place without keeping any userwaiting and the results stored for use in online queries. Thesequestions can be questions that have previously been seen during onlineprocessing or where analysis of logs shows that they are frequentlyasked. This offline-only approach is the approach taken by a preferredexample.

Questions are answered by executing a series of subqueries generated byreasoning that allow us to eventually find passages that answer thequestion. Certain subqueries appear frequently when processing differentquestions. Remembering these subqueries and processing them more deeplyoffline allows us to answer questions more quickly in general, and toreturn better results (because we've reasoned more deeply about thesubqueries, giving us an opportunity to find more solutions). We callthe output of this processing thinking results.

In an example, we store two types of information during the thinkingresults process: the thinking results themselves (i.e. solutions toquestions), and metadata about the thinking results which comprises arecord that we thought about the question at all and how often theresults are used.

Thinking Results Storage

As previously described, question processing uses three methods: directlookup of passages that can be unified with the current subquery; use ofcomputation units; and reasoning. We store thinking results by storingthe intermediate passages that are derived during reasoning, which canthen in future be found by direct lookup.

For example, if we ask ((Question X) (IsA X Aerodrome)), we might answerX=Gatwick based on the following reasoning:

(IsA GatwickAirport Aerodrome)

-   -   Reasoning passage: (ConsequenceOf ((IsA A B) (IsSubclassOf B C))        ((IsA A C))) (IsA GatwickAirport Airport)        -   Reasoning passage: (ConsequenceOf ((IsA A B) (IsSubclassOf B            C)) ((IsA A C)))            -   Known: (IsA GatwickAirport InternationalAirport)            -   Known: (IsSubclassOf InternationalAirport Airport)        -   Known: (IsSubclassOf Airport Aerodrome)

We would store (IsA GatwickAirport Airport) and (IsA GatwickAirportAerodrome) (both the final answer and the intermediate passage) asthough they were normal passages entered by a user or otherwise learned.If we are later asked the same question, the answer can come from adirect look up of (IsA X Aerodrome) without requiring any reasoning.This also works for subqueries: if some other question reasons to thesubquery (IsA X Aerodrome) or (IsA X Airport) then we can use thinkingresults directly rather than further reasoning.

Thinking results, while simply passages like any other, may be stored intheir own passage store, separate from other passages, so they can beeasily identified and handled—including appropriately expiring.

Along with each new passage stored in thinking results, we may alsostore the explanation. This is useful in order to preserve the stepsused to arrive at the result. Without this, the explanation of X=Gatwickto the above question would simply be Known: (IsA GatwickAirportAerodrome). Finally, we may also store the dependent passages: these arethe passages (reasoning or otherwise) that were used to arrive at theanswer. If any of these passages are updated or deleted, we delete thethinking result, as it may no longer be valid.

In examples, we also take care to appropriately store passages for onlyas long as they can reasonably be expected to be valid. Some passagesare only true momentarily—for example the price of an actively tradedcommodity—or the local time at a particular location; some passages havea far longer half-life of validity, such as a political office-holder,and some passages stay true indefinitely.

Question Answering with Thinking Results

To incorporate the above thinking results into our question answeringprocess we query the thinking results passage store when looking forpassages that can be directly unified with the current subquery, asalready described above. However, nothing as described currentlyprevents the system from continuing to reason about the subquery,including potentially reasoning to exactly the same results as thethinking results provide. We may need to know that we've thought aboutthis subquery before, so that we can avoid reasoning about it again.This is why it is preferred to also store metadata about the thinkingresults.

Metadata

As well as storing a passage such as (IsA GatwickAirport Aerodrome), wealso record that we've thought about (IsA X Aerodrome). We check thisset of subqueries we've thought about prior to doing any reasoning aboutthem. If we find that we've previously thought about them, we disablereasoning for the subquery, and attempt only direct unification. Tospeed things up further, we may also record the number of solutionsproduced by processing the subquery. If this is zero, we can avoidsearching for passages that unify with the current subquery: we knowthere are none.

Offline Process

In a preferred example, an offline process runs questions using a veryhigh reasoning effort and stores the resulting thinking results in themanner already described. The metadata is stored in a distributedin-memory cache; we store that the question has been processed, alongwith when, and the number of solutions generated. Subqueries generatedwhile reasoning are also added to the distributed cache.

The offline process may run continuously, choosing questions to processbased on their hit count (see below) and how long ago we last processedthat question. Questions with low hit counts that were processed sometime ago are removed from the cache—or where there is evidence that theresults may have expired.

Online Question Answering

Before answering a top level question outside of the offline process(i.e. a question that must be answered quickly), a preferred exampleconsults the distributed cache to see if the question has been processedwith thinking results, and processed recently enough. If so, we processthe question with no reasoning (i.e. we use the thinking results). Ifthe cache tells us the question led to no thinking results, we returnimmediately, without querying for the thinking results. In this case, wereturn almost instantly with high quality results.

If thinking results are not available (either we've not processed thequestion before, or we did so too long ago) we proceed as normal (i.e.with reasoning until we hit the reasoning effort threshold or terminatefor some other reason). We continue to consult the cache for subqueriesand do no reasoning for any subqueries that are in the cache (andentirely avoid database lookups if the cache tells us there are noresults). We don't adjust our reasoning budget in any way if we findsuch cache hits for subqueries. In this case, thinking results do notimprove performance, but they may improve result quality significantly(if there are thinking results for subqueries).

Whenever we consult the cache, we record a hit on that query. If thequery doesn't exist yet in the cache, we add it with a hit count of 1.

Various examples may choose to periodically remove thinking resultswhich are insufficiently or infrequently used or never used, even ifstill considered valid, for space reasons.

According to various examples including a preferred example the metadatamay include all the stored passages including reasoning passages thatwere used to generate the result. In examples where passages maysubsequently be discovered to be untrue, invalid, or to have changed,this metadata enables thinking results that rely on this invalid passageto be immediately removed. If a thinking result uses another thinkingresult to generate a result, then the dependent passages for the usedthinking result are included in the dependencies of the new thinkingresult.

Auto-Curation

Various examples may utilise a process of automated curation todetermine the value of passages stored in a passage store. The benefitof this technique is to scalably maintain a vast amount of informationrepresented in UL without the need or with less of a need for humancuration. The value of a passage determined with this process is thenused by the reasoning engine in the question processor to determinewhether or not it should use the passage. This enables passages to besourced from low-quality or unknown quality sources knowing that badpassages will eventually be switched off or no longer used. Putdifferently, it enables the system to learn which of its stored passagesare useful, true or otherwise valuable and which are not.

When a new passage is added to the store by a person it is assigned alow initial trust value when added by a normal user. A privileged useror a user that the system has learned to trust may result in a higherstarting value. The reasoning engine can then be instructed to be moreexperimental when processing questions which means that it can try touse less valued passages to answer the question. The answers provided byan experimental reasoning engine are then monitored for any signals thatwould indicate whether the low-value passage had a positive or negativeeffect on the answers. This information then feeds back into theauto-curation process which reevaluates the value of the passage withthe new signal.

Examples of signals used include the results of test questions withknown good answers: passages which support or are compatible with thesewhen used produce a positive signal for that passage, while those thatresult in wrong results or which substantially slow the production ofgood results result in a negative signal. Signals can also come fromreal-world results. Information from a user that the system has producedsomething valuable will send a positive signal to all passages of allkinds that were used to generate that result. Similarly feedback thatthe result is bad will taint all the used passages. Some good passagesmay be tainted unfairly but over time they will also receive positivesignal and it will be possible to determine constituent passages thatare consistently the source of negative results.

Value Vector

According to various examples, the overall value of a passage is acombination of factors that can change depending on the system orprocess that wants to use it and the context. For this reason, passagesmay be assigned a vector of values where each number represents adifferent quality of the passage. This allows us to have a differentdimension for veracity, usefulness, and efficiency. Then the processthat uses the passages just has to utilise a priorities vector withnumbers at each index that indicate how much they prioritise that valueand the overall value of the passage to that process can then beobtained from the dot product of the two vectors. However, it issometimes useful to use the values individually in certain contexts,where knowledge of that score's applicability to that context can beused to optimise our use of the passage. For example, allocatingreasoning budget in the question processor can be based primarily on theefficiency score.

Offline Processing and Experimentation

A further method for auto-curation is to run a continuous process thatreprocesses questions it has seen in production with a higherexperimentation level to test whether any low-value passages might havebeen helpful for finding more answers. Any low-value passages that dohelp provide further answers can then be boosted with a positive signal.According to other examples, an offline process can run test questionswith known answers using the passage being tested and see if it causeswrong or extraneous answers to be found or to otherwise have anunacceptable impact on the performance of the system (such as poorerlatency). This can be used to verify passages containing information andcan be used for passages such as reasoning passages. Passages determinedto be detrimental from this test process can be ignored for productionuse.

Learning

Examples of the present invention including examples implementing any ofthe applications described herein or other applications can learn,representing what they have learned in UL (or similar) and thenutilising that stored UL to improve their performance. The learnedpassages are stored in long or short-term memory and utilised indelivering the application.

This approach contrasts with what is commonly referred to asmachine-learning in the prior art where what is learned are parametersor weights which allow a model to perform statistically better at aclassifications, regressions or other tasks. Examples can also combinethe language-based learning described herein with statisticalmachine-learning.

The learning described herein are not weights but concepts and ideasexpressed in language and translatable into natural language enablingexamples of the present invention to reason with what they have learnedand explain what they have learned to human users. The learning alsoenables conversation in text or spoken language with users in a way thatweights in a statistical model do not.

Sources/methods for learning in examples of the present inventioninclude:

(a) learning from conversation or other natural language provided byusers: by translating natural language provided by users in spoken orwritten form into UL and storing it, the concepts, ideas and knowledgerepresented in the stored UL is learned and can be utilised.

(b) learning from reasoning: UL that is generated from a chain ofreasoning, can be stored and utilised. The reasoning may be directed toa particular goal such as answering a question or the result ofundirected thinking designed to find ideas that may be useful.

(c) learning from other natural language. By translating all or parts ofdocuments such as web pages, scientific papers or other articles intoUL, the resulting UL can be utilised by applications as describedherein. Other sources of natural language can include audio recordingsor videos containing human speech where speech recognition technology isfirst utilised to create a text transcription of the recordings of voicewhich are then translated into UL. In some examples a neural network maybe trained end-to-end to turn audio data directly into UL. For video,examples may combine knowledge of what is shown in the video, forexample as described by a machine-learning model designed to analyse thecontent of the video with the simultaneous audio to better translate theaudio or to augment the audio with additional information which isrecorded in the learned UL.

(d) learning from structured data. Structured data such as the contentof a table found in a document or on the web, a spreadsheet or thecontents of a relational, graph or other database. Structured data alsoincludes formats such as JSON which may be the output of automatedsystems. Structured data can be turned into UL by assigning semanticnodes to the identifiers in the structured data or relationscorresponding to the relations in a relational database and generatingUL that corresponds to the meaning of the structured data.

(e) learning from analysis of other data. Examples of the presentinvention may analyse data, processing the data with an algorithm andexpress the results of that analysis in UL. By storing the resulting ULthe analysis and derived data is available to the system in a form thatcan be processed and reasoned with as described herein. In some examplesthe analysis can be done with a machine-learning model.

Distributed Use. Semantic Node Resolution.

As previously described a preferred example enables any user of UL touse any new ID for any node—essentially a private ID. However, if thatentity is being used elsewhere it may make sense for that user to use ashared ID for the node.

To enable this to happen, a service of a preferred example is providinga shared ID to a node from a description of the node. This is referredto herein as Semantic Node Resolution (SNR).

To enable this service it requires information about the existingsemantic nodes that the service may return represented in UL. For sharednodes this information will typically be public but may also be based onadditional private information about the node. When the SNR service iscalled, the caller provides a description, giving information about theentity for which a semantic node is requested. In various examples, thiscaller's description might be in UL or it might be a natural languagedescription—or a combination of the two.

The SNR service then compares the known information about the describedentity with the description it has about existing nodes to see whetherit can confidently match the new node with a known node and thus providea shared ID.

To do this the SNR considers potential matches and then tries toestimate the probability that these are two different nodes. Beyond acertain threshold probability, e.g. 0.999, the shared node is provided.In various examples, possible matches might be returned with theirprobabilities enabling the caller to decide for themselves whether touse the shared ID or a new one.

The probability calculation is used by combining probabilities fromvarious parts of the description.

For example, supposing the unknown node is a human being, with firstname “William” and last name “MacDonald” and with a date of birth 1953Apr. 2 and country of birth Ireland. With just a date of birth matching,the resolution could not happen as many tens of thousands of peopleshare the same date of birth but combining it with a shared country ofbirth and shared name the probability that they are the same nodebecomes very high and using the shared ID becomes reasonable. Theimplementation of this for humans would include heuristics and data toestimate the probability of any human having a particular date of birthor a particular name, combining those probabilities and then comparingthat with the universe of possible entities in that class. Thesecalculations can be used to estimate a probability of the match beingunique.

Note that some probabilities can be considered independent andmultiplied while others are not independent so need to be combined withcaution. For example, being female halves the possibilities as there areapproximately equal numbers of men and women. The name Jane reduces thepossibilities significantly as only a small percentage of people arecalled Jane but knowing that the node has first name Jane and is femalegives very little extra information over just first name Jane as almostall people with first name Jane consider themselves female. There aremore subtle non-interdependencies too. Name probabilities varyconsiderably with country of birth for example.

The immediate use of SNR is providing a shared ID which can then beconfidently used by the calling user. In some cases, the level ofconfidence may not be sufficient to immediately use the shared ID andthe caller may instead prefer to use a new or private ID until moreinformation is known in order to make a match. SNR can also be usedafter a passage has been written with one or more private IDs with thegoal of a subsequent step where the passage is rewritten replacing oneor more private IDs with public IDs. It can be similarly used to mergepublic ids which denote the same entity. Identifying them as being thesame might not have been possible when they were first used.

Multiple UL Stores

Examples of the current invention enable passages to be stored inmultiple separate stores. Stores can be used for different purposes andcan have different access controls. Different stores could also havedifferent trust levels. For example, various examples could maintainaccess to a UL store that contains highly trusted passages thatrepresent common sense information about many of the widely usedsemantic nodes and with reasoning passages that are useful and notdisputed. Another UL store may contain employee and human resourcerecords of a private enterprise and have access heavily restricted toselected people within that private organisation. In some examples, therestrictions may apply to organisations. A UL representation of aparticular natural language book may be given its own store.

According to various examples, UL stores can be shared between multipleusers. For example, a trusted core UL store of widely used semanticrelations could be made widely available. UL representations of books orkey stores of knowledge could be commercially licensed by organisationsthat build and maintain them.

Translation

Translation is the act of turning UL into natural language and from ULinto natural language for the purpose of communicating with humans,learning, making sense of information stored in natural language amongother purposes.

Neural Machine Translation

Neural machine translation is the term for prior art methods used forusing neural networks to translate between pairs (or more) of naturallanguages. A typical architecture includes an encoder which turns asource sentence into an internal vector or sequence of vectors thatencodes the source sentence which is then read by a decoder whichgenerates a corresponding sequence of words in the target language.Variants of the architecture use recurrent neural networks includingLong Short-Term Memories (LSTMs), various attention mechanisms and mostrecently Transformers. Such architectures can be considered conditionallanguage models where output of the language mode is conditioned by thesource language which is input.

Examples of the present invention utilise neural machine translationarchitectures, but instead of using only natural languages they utiliseneural networks that have been trained with translations between anatural language and UL (or similar). The resulting neural network canthen generate UL which corresponds to the meaning of the input naturallanguage. In a preferred example the vocabulary includes semantic nodesand the left and right parenthesis symbol.

An important point is that in contrast to a neural translation systemtranslating between natural languages, a neural architecture designed totranslate between a natural language and UL can be considered to be asystem to understand natural language as the resulting UL (or ULsimilar) representation fully represents the semantics of the sourcenatural language and is machine-processable. This UL can then be usedfor reasoning, question answering and other actions and applications asdescribed herein. In machine translation systems between naturallanguages both the source and target translations exhibit all the issueswith machine understanding that exist with all natural languages andwhich have been previously described herein.

Beam searching is a method where instead of just reading off the mostprobable output symbol from the decoder in a neural machine translationsystem at each step, a range of possible outputs from the decoder ismaintained along with their probabilities which can be used to generatea list of probable translations. Examples of the present inventioncapable of validating UL use beam searching and remove invalid ULtranslations from the results ensuring that the generated UL ismeaningful. Automatic validation of UL may also be used to ensure thatthe system is only trained with valid UL. According to various examplesautomatic validation can be done with Validation Passages (as describedherein).

Other Translation Methods/Alternative Examples

One method for translation to and from UL as used in some examples isdone by looking at UL passages which have been marked as “Ground truthtranslations”. These are known translations between a UL passage and apassage written in a natural language such as English which are assumedto be accurate. In some examples these may simply be stored in adatabase listing the ground truth translations against the correspondingUL passages. In some examples translations may themselves be stored asUL such as this:

(EnglishGroundTruthTranslation (IsA Brie ((Cheese French) Creamy)) “Brieis a creamy French cheese”)

Which says that ‘Brie is a creamy French cheese’ is an accurate Englishtranslation of (IsA Brie ((Cheese French) Creamy)). If we were to callthis passage GroundTruthTranslation1 and we had (IsAGroundTruthTranslation1 GroundTruthTranslation) in the store as well,then we could use this known ‘correct’ translation as a basis for othersimilar translations. Using the above, perfect translations can begenerated whenever there is an exact match such as “Brie is a creamyFrench cheese” into and out of UL. These passages can also be used totranslate things that are not an exact match. A simple example of anon-exact match might be the English passage “Camembert is a creamyFrench cheese.”

The method used in some examples depends on which direction we need totranslate. When translating from natural language into UL, we break downthe structure of the given sentence and compare it to the structure ofeach of the known ground truth translations to sort by similarity. Thesentences are split into words (or other atomic parts of the language)and then re-merged into subparts (sequences of words) that we have anexisting translation for such as (ExpressedInEnglish Camembert“Camembert”) and (ExpressedInEnglish IsA “is a”). These two passageswould mean that the Camembert node becomes an option for the “Camembert”part of the sentence and IsA becomes an option for the “is a” part. When“Camembert is a creamy French cheese” is matched againstGroundTruthTranslation1, the translator will give a high similarityscore because most of the sentence is the same and the only part that isdifferent (“Camembert”) has the same part of speech as “Brie” and has anoption (Camembert) in the list which is very “similar” to the node usedin GroundTruthTranslation1 which was Brie. In a preferred example, thesimilarity of these two nodes is compared using a component of the ULplatform called the entity resolver.

According to various examples, the entity resolver currently works bycomparing large numbers of passages that the two nodes are used in anddetermining how similarly they are used. If they are used in almostsimilar ways then they are more likely to be very similar nodes forwhich a straight substitution in a translation is likely to be accurate.For example, they may belong to the same class so we may see (IsA BrieCheese) and (IsA Camembert Cheese), which are both identical other thanthe nodes we are comparing. In other examples, the entity resolvercombines further heuristics or properties in order to determine thesimilarity of two given nodes.

Translating from UL to English makes use of the entity resolvercomponent again to compare the UL we are translating against the knownground truth translations and to pick the most similar one. The nodesthat are different then have their translations replaced to form thefinal output string.

Word embeddings such as word2vec or GloVe is a technique known by thoseskilled in the relevant art in which large volumes of text are analysedto determine words that have similar meaning and usage. Various examplesmake use of this technique to determine the similarity of the naturallanguage words and their suitability for substitution in a known groundtruth translation. For example, an analysis of English would determinethat Camembert and Brie were very similar items as their word embeddingswould be very near each other. This means a ground truth translationincluding Brie would almost certainly stand with the word Briesubstituted for Camembert as well as an exchange of the semantic nodesin the UL half of the translation.

Another technique used by various examples involves automaticallyassessing the semantic impact of changes in natural language wording. Innatural language there is often many ways to say the same thing.Sometimes rephrasings result in another passage with identical meaning,on other occasions, the change in semantics is small. In other cases, itis large. With an automatic method of assessing semantic impact betweentwo natural language passages, ground truth translations can be usedwhen the assessment is that the semantic impact is small ornon-existent, even if there is not an exact match with the naturallanguage in the ground truth translation.

Examples of techniques that can be used by the semantic impactassessment would be noticing the substitution of words known to besynonyms or words of similar meaning, rephrasings that are known to beother ways of expressing the same thing (e.g. talking in English about“<noun1> of <noun2>” and “<noun2>'s <noun1>”), and the addition offiller words that only subtly change the meaning when they are used.

According to various examples, the translator in each direction uses apipeline where each pipe is a function that takes in a documentstructure and returns a new document structure. Each pipe can addcomponents to the document for use by later pipes. The final documentcontains a component that the pipeline considers an output component andthe pipeline returns this as the output. The first pipe in each pipelineis for a direct lookup in the cache, if this returns a successfultranslation then the rest of the pipes can be skipped. In the case ofEnglish to UL, we then run a series of pipes that make use ofStanfordCoreNLP libraries or similar to tokenize the sentence, and totag it with part of speech information that can be used to help theground truth translator pipe determine the best match in a later pipe.When translating from UL to English, the only pipe used before groundtruth translations is the direct lookup pipe since the UL itself shouldalready give enough semantic information to be translated back intonatural language.

An optimisation present in various examples is to use a Bloom filter toidentify language passages which are not present in the store oftranslations, in order to reduce the load to the system. A Bloom filteris a space-efficient probabilistic data structure, that is used to testwhether an element is a member of a set.

According to various examples the translator would actively try to varythe translations to natural language between a wide range ofsemantically equivalent and natural translations to create varied andfresh speech for the benefit of the users of the products powered by thepresent invention. For ground truth translations this can be done byselecting randomly between multiple translations for the same UL. Theother techniques described herein either also naturally produce multiplecandidate translations or can be easily adapted to do so.

Translation Context

UL can encode self-referential and meta-linguistic statements: it ispossible to describe in UL how and when to translate, and what is moreappropriate in one context than another. For some applications it isdesirable to have the ability to generate translations applicablespecifically in the present context. Some examples utilise a method toexpress in UL descriptive, contextual information about the semanticnodes which are likely to be translated. By having this informationpresent and available to the system at runtime, programmatic reasoningis able to select the most appropriate attribute from those available(e.g. “vehicle”, “car”, “my Audi”) which can then be substituted for theoriginal node in a preprocessing step. Other translation techniques canthen be applied to render this in natural language.

Translation Between Natural Languages

A goal of UL is to fully represent the meaning of any natural languageand the language is easily extendible to accommodate nuance and newconcepts that come from new languages which may not have been createdbefore. This means that that once a document or piece of naturallanguage has been translated into UL nothing has been lost and the ULtranslation can contain all the semantics and nuance of the original.This contrasts with a single natural language which is naturally animprecise translation of the source language with words which do notquite mean the same or even words which do not exist in the targetlanguage.

For this reason, an improved method for translating between manylanguages is to build a translator from and to UL for each naturallanguage and translate between natural languages by first translatingthe source language into UL and then translate from UL into thedestination language.

Prior art translation systems such as neural machine translation systemstypically learn from examples of text between pairs of naturallanguages—or have effort and resource directed to specific languagepairs. That means that with n languages you would need of the order of nsquared translation systems in order to accommodate all language pairs.With UL being an effective intermediate language the number of systemsyou would need to build would be 2n—a UL→NL and a NL→UL system for eachlanguage.

Representation of Emotion, Connotation Etc.

Words in natural language often have connotations or inferences thataugment or are in addition to their pure semantics. For example, inEnglish there are multiple synonyms for the word “error” such as“boo-boo”, “screw-up”, “inaccuracy”, “blunder” etc. Although consideredsynonyms, these different words have different connotations and usages.For example, the word “boo-boo” is used for children or to mock anadult; the word “inaccuracy” expresses politeness or a relatively minorerror; a “blunder” implies a large error where there is considerableblame on the person making it.

According to various examples these connotations and usages can berepresented by having a different semantic node corresponding to each ofthese concepts. The meaning that includes these connotations can berepresented in other UL that ties these semantic nodes to similar butdifferent ones whilst also explaining the differences.

The use of nesting can be used to represent emotion and tone in writingas well as other properties such as nuance or level of formality. Forexample, semantic nodes representing an angry tone of voice can becombined with the passage being spoken to represent that passagecommunicated in an angry tone of voice. In examples with voice,representations like this can be used to modify the generated sound toinclude emotion appropriately in the output.

Specific Applications Built on Examples of the Present Invention

Recruitment Application

An automatic recruitment application is one that tries to find highlyqualified candidates for a given position automatically: matching arepresentation of the potential applicant's résumé with a representationof the role and job specification. Further examples of such anapplication may also match an applicant's desired role with the jobdescription as well as assessing how well the applicant is qualified.

There may be hundreds of thousands of possible candidates online who maybe a match for a given job. Recruitment prior to the present inventionis typically done by humans using tools to search a database of suchcandidates. Typically, such searches are either done purely onunstructured data—searching for keywords in their résumés, sometimescombined with limited structured data. For example, a job applicationspecialising in finding software engineering talent may includestructured data for common programming languages and the search box, inaddition to allowing searches for keyboard, may also include drop-downsor check boxes for these specific skills. This limited structured datais created in the conventional way with a database schema and specificcode to include this data in the search.

Additionally, some applications attempt to apply state-of-the-art NLPtechniques to both the résumé and the job specification and then attemptto rank the applications by how good a statistical match they are to thespecification. The limitations of state-of-the-art of NLP will mean thatthe ranking is only approximate and heavily influenced by similarkeywords in both the résumé and job specification. It will provide somevalue to a recruiter who wants to narrow down the list of résumés butsubstantial human involvement will still be needed to have highconfidence in a good match and the recruiter may fail to see a goodmatch as a result.

In reality the number of different skills or experiences that mightappear in a résumé or job specification is very large, meaning that anystructured data decided upon and programmed into the system can onlycover a small fraction of what might be searched for.

Automatic recruitment is thus an example of a HUB application.

An example application called Jobe is described herein. It represents apreferred example and other relevant examples of a recruitmentapplication.

In a preferred example a large part of the job specification andcandidate's résumé is represented in UL or similar and the reasoningmethods described herein are used to determine whether they match. Invarious examples a UL or similar representation of at least some of thecandidate's objectives is also matched with the job specification andpossibly a description of the employer.

FIG. 1 shows an example of a push notification on a mobile phone fromJobe notifying the user of a new candidate who is a perfect match forone of their jobs. This match happened automatically. Had the match beenstatistical or using existing inexact methods, the application designerwould not have had the confidence to interrupt the user with thismessage as the match would be far too frequently poor. Because thetechnology in this application is based on an example of the presentinvention, the automatic match is known with very high confidence to begood and so interrupting the user is a good product experience. Thepresent invention, in an example, thus enables a product experience thatwas hitherto not possible.

FIG. 2 shows an example of the details of the match, where requirementsfor the role are justified with data from the candidate's résumé. FIG. 2illustrates three example job requirements for a junior softwareengineer position: experience with a major object oriented language,fluency in a foreign language and their location. Specifically Jobe hasmatched the requirement “1+years in a major object oriented language”with “3 years programming in C++”; inferred fluency in Portuguese fromthe fact the candidate attended high school in Brazil where thepredominant language is Portuguese and that the candidate is “withincommuting distance of London” by the fact that she lives in Hitchin,Hertfordshire, UK.

In these examples, none of the evidence from the résumé that they matchshares any keywords with the actual requirement. All three matches alsorequire reasoning with the UL representation and come from the semanticsof the requirement and the job specification.

To further illustrate here is how one of these matches is done using UL:

As described herein examples of the present invention can answer answerYes/No questions. In order to match a similar candidate, the system hasasked itself the question “Does 7 years' experience of C++ imply atleast five years' experience of programming a major object-orientedlanguage?”

“7 years' experience of C++” can be represented in UL as ((ExperienceCPlusPlus) (Year (RealNumber “7”))— Experience combines with anothersemantic node to represent experience with that concept. Year representsthe unit of time and combined with number gives a number of years oftime.

“at least five years' experience of programming a major object-orientedlanguage” can be represented as

((Experience (Programming (UnspecifiedMember ((ProgrammingLanguageObjectOriented) Major)))) (Year (AtLeast (RealNumber “5”))))

AtLeast in combination with a number gives a number range. Thus, incombination with a unit gives a unit range. In this case a minimumnumber of years. UnspecifiedMember represents a member of a class whichisn't identified.

Therefore, the whole question can be represented in UL as follows:

((Question) (Implies ((Experience CPlusPlus) (Year (RealNumber “7”)))((Experience (Programming (UnspecifiedMember ((ProgrammingLanguageObjectOriented) Major)))) (Year (AtLeast (RealNumber “5”))))))

To answer this question, the following trusted passages are utilisedfrom a UL store that represents recruitment related information.According to various examples, these passages have been generated fromconversation between the system and people, translating the naturallanguage into UL or added directly by trusted people, building therecruitment application.

(IsA ProgrammingLanguage Class)

(IsA ObjectOriented Attribute)

(IsA Major Attribute)

(IsA CPlusPlus ProgrammingLanguage)

(IsA CPlusPlus ((ProgrammingLanguage ObjectOriented) Major))

(IsA Year Unit)

As well as these known passages, a computation unit and reasoningpassages are required. The computation unit, used for comparing if 7 isgreater than or equal to 5, is defined as follows:

(ComputationInputs GreaterThanOrEqualComputationUnit InputOne InputTwo)(ComputationDescription GreaterThanOrEqualComputationUnit ((Question)((GreaterThanOrEqual (RealNumber InputOne) (RealNumber InputTwo)))))

(ComputationLocalJavaLocation GreaterThanOrEqualComputationUnit“ai.unlikely.questionprocessor.computation.Comparison$GreaterThanOrEqual”)

And the needed reasoning passages used for this question are:

Core reasoning passages that help define the IsSubclassOf relation

(ConsequenceOf (IsSubclassOf A B) (IsA (UnspecifiedMember A) B))(ConsequenceOf ((IsSubclassOf X Y) (IsA A Attribute)) (IsSubclassOf (XA) Y)) (ConsequenceOf (IsA X Class) (IsSubclassOf X X))

Reasoning to do with quantities, activities, implication etc.:

(ConsequenceOf ((Implies X Y) (QuantityWithinRange A B)) (Implies (X A)(Y B)))

(ConsequenceOf ((IsA X ProgrammingLanguage) (Implies (Experience(Programming X)) Z)) (Implies (Experience X) Z))

(ConsequenceOf ((IsA X Activity) (IsA Y Activity) (Implies X Y))(Implies (Experience X) (Experience Y)))

Programming a programming language is an activity

(ConsequenceOf (IsA X ProgrammingLanguage) (IsA (Programming X)Activity))

If X is a programming language and a member of the class C, programmingX implies programming a member of C

(ConsequenceOf ((IsA X ProgrammingLanguage) (IsA X C)) (Implies(Programming X) (Programming (UnspecifiedMember C))))

If A is within the range B and X is any unit, then A of X is in therange B of X (ConsequenceOf ((IsA X Unit) (WithinRange A B))(QuantityWithinRange (X A) (X B)))

If X is greater than Y then X is within the range at least y(ConsequenceOf (GreaterThanOrEqual X Y) (WithinRange X (AtLeast Y)))

Using the question answering methods described herein, a Yes result canbe generated to the question.

To further illustrate the method, the following explanation showing thesteps that may be generated by some examples utilizing the reasoningmethod described herein:

(Implies ((Experience CPlusPlus) (Year (RealNumber “7”))) ((Experience(Programming (UnspecifiedMember ((ProgrammingLanguage ObjectOriented)Major)))) (Year (AtLeast (RealNumber “5”)))))

-   -   (Implies (Experience CPlusPlus) (Experience (Programming        (UnspecifiedMember ((ProgrammingLanguage ObjectOriented)        Major)))))        -   Known: (IsA CPlusPlus ProgrammingLanguage)        -   (Implies (Experience (Programming CPlusPlus)) (Experience            (Programming

(UnspecifiedMember ((ProgrammingLanguage ObjectOriented) Major)))))

-   -   (IsA (Programming CPlusPlus) Activity)        -   Known: (IsA CPlusPlus ProgrammingLanguage)    -   (IsA (Programming (UnspecifiedMember ((ProgrammingLanguage        ObjectOriented) Major))) Activity)        -   (IsA (UnspecifiedMember ((ProgrammingLanguage            ObjectOriented) Major)) ProgrammingLanguage)            -   (IsSubclassOf ((ProgrammingLanguage ObjectOriented)                Major) ProgrammingLanguage)                -   (IsSubclassOf (ProgrammingLanguage ObjectOriented)                    ProgrammingLanguage) (IsSubclassOf                    ProgrammingLanguage ProgrammingLanguage)                -    Known: (IsA ProgrammingLanguage Class)                -   Known: (IsA ObjectOriented Attribute)            -   Known: (IsA Major Attribute)        -   (Implies (Programming CPlusPlus) (Programming            (UnspecifiedMember ((ProgrammingLanguage ObjectOriented)            Major))))        -   Known: (IsA CPlusPlus ProgrammingLanguage)        -   Known: (IsA CPlusPlus ((ProgrammingLanguage ObjectOriented)            Major))    -   (QuantityWithinRange (Year (RealNumber “7”)) (Year (AtLeast        (RealNumber “5”))))        -   Known: (IsA Year Unit)        -   (WithinRange (RealNumber “7”) (AtLeast (RealNumber “5”)))        -   Computed: (GreaterThanOrEqual (RealNumber “7”) (RealNumber            “5”))

Various examples may generate a natural language translation of thesesteps, either a full one showing every step or with obvious common-sensesteps skipped to create a simplified explanation that is easier tounderstand. Examples of such an explanation generated by variousexamples are shown in FIG. 7 .

Horizontal Health Application

A horizontal health application is an application which attempts torecord and manage an extremely diverse set of health data from one ormore users. As discussed herein, representing this data in a way thatcan be understood and managed by a computer system is impractical usingthe state-of-the-art prior to the current invention.

Nutrition: there are millions of different foods and millions ofdifferent consumable substances. These substances are sometimes related(e.g. types of fat) and they have numerous different attributes. Theinteraction of these substances together and with the human body ishighly complex—and a deep semantic representation of nutrition couldallow computer-based systems to give very sophisticated dietary adviceand unlock interactions which have not been previously observed.Nutrition is thus a HUB application.

Health more generally is also an example of an unreasonably broaddomain. Nutrition is a sub-domain of this extremely broad domain. Anapplication that tracks a person's day to day health information wouldneed to combine numerous health tests and include domains such as levelsof certain substances in blood, measurements of organs, measurements ofbody composition, measurements of the performance of the body in variousdomains, activity information, nutrition information, genetic data,microbiome data, sleep data, specific events that influence health(workouts, consumption, drinking of substances, moods, bowel motions) aswell as numerous documented health conditions and diseases. Any one ofthese types of data can be relevant to others as well as to thepatient's health goals. Although small subsets of these can be builtwith the typical local schema effort that we see today, building a hugegeneric health application that can potentially encompass all of thisinformation was not practical prior to the current invention.

“Chea” is an example application from this class of applicationsdescribed herein. It represents a preferred example and other examplesof the present invention.

In addition to recording health data from wearables and other healthsensors, Chea has a chat window where a user can communicate healthrelated events as they happen and have them understood, stored andprocessed by the application. Example health events could be nutritionalevents: consuming food and drink. This window can also be usedoptionally to record other health events: specific symptoms ofillnesses, information about mood and energy levels, bowel motionscharacterised on the Bristol stool chart etc.

FIG. 3 shows a conversation within the app where nutritional data isbeing communicated with the app. In a preferred example conversation isbetween the user, the AI, any number of human medical professionals andhuman nutritionists who derive semantic nutritional data from photos anddescriptions of food and drink entered by the user when they areconsumed. The AI can handle what is possible with humans picking upother tasks where automatic processing is not possible. An example of anautomatic task would be prompting a user when nutritional information orother supposedly regularly supplied health information has not beenadded for a period. For example, if a long period of the day went bywithout any food or drink being entered the AI could ask the userwhether this had actually happened or whether they had forgotten. If theuser was intending to log details of bowel motions they could also beprompted if an unusually large gap appeared with no information beingshared. The semantic nutritional data not only represents exactly whatwas consumed and when but also represents uncertainty—e.g. from notknowing the exact composition of the food, to uncertainty about theportion size from the images.

UL supports this uncertainty. For example, it may not be possible todetermine what kind of cheese is being shown in an image and the usermay also not know but the semantic node for cheese can be used in thatcircumstance. If a more precise type of cheese is in the recipe such asCheddar or even a very specific type of cheddar, then the appropriatesemantic node can be used for that. Passages in a trusted storerepresent the relationship between Cheese and specific types of cheeseas well as much pertinent information about these nodes.

UL can represent information about the likely constituent substances offoodstuffs too. For example, if the image was of a portion of chickenpie, UL can represent the composition of chicken pie including both thepie crust and the typical ingredients of the pie portion. Uncertaintiesin exactly what those ingredients are and the variations in volume canalso be represented in UL. That combined with the uncertainty in theportion shown, as communicated by the nutritionist can be combined toinclude a detailed semantic breakdown of that meal with uncertaintiesand that can be recorded. As this nutritional data is fully semantic andthe application also has relationships and other information about thesesubstances represented in UL, the data can be looked at in manydifferent ways and measured and charted through many different lenses toderive health insights.

FIG. 4 shows some example insights that can be derived from a period oftime where horizontal health and nutrition data was shown. By combiningdata from wearables including pulse and sleep data as well aspotentially other events and mild illness recorded in the conversationdata and correlating these negative events to ingestion of certainsubstances the app has concluded that the user may have a mild dietaryintolerance to sulphites. Armed with this information, the app couldhelp the user steer away from foods that contain this substance in thefuture. A second example insight provided in this figure is the strongrelationship found for this user between eating earlier and sleepingbetter. Being a horizontal health application, sleep data from wearablesis available and can be compared over a period of time with thenutritional data which includes the time it was consumed. With enoughdata this insight can be shared definitively with the user who can thenimprove their sleep and thus their health by aiming to eat earlier thanthey previously have been. Such insights would not be possible withoutan extremely broad range of health data both stored and stored in asemantic way accessible to the machine, thus enabling these automaticinsights to be generated.

FIG. 5 shows an example graph showing daily calories in versus caloriesout which is an extremely common thing for someone to track if the useris aiming to lose (or gain) weight. The detailed semantic informationabout what the user has consumed enables the graph to be shown witherror bars giving an accurate range of the calories ingested in a givenday. A wearable measuring physical activity by the user combined withdata on their weight enables an accurate estimate of calories consumedduring the day, also with error bars. Unlike other applications whichestimate calories with no error bar, this approach is able to be moresophisticated about days when the user is likely to lose weight by alsoidentifying days when the two measures are too close to be able to saywhether they were in deficit or surplus—the error bars overlap. This isa better approach than other application which give false precision ascalorie measurement is inherently error prone and it is entirelypossible to be several hundred calories out when assessing food intakegiving the user the false impression they are in a calorie deficit whenin reality they are not.

FIG. 6 shows an example of another visualisation capable of beinggenerated from an example of the present invention. It is comparingestimated caffeine in the user's body at the time they went to bed witha calculation of sleep quality. The sleep quality measure comes from oneor more wearables and is calculated by combining various measurements ofsleep. The caffeine at bedtime comes from estimates derived fromnutritional data collected by the app. For example, a cup of coffeeconsumed at 2 pm can have an estimate of the caffeine within it and byassuming a half-life for the user's ability to metabolise the caffeineout of their body an estimate can be made for how much of this caffeineremains at their known time of going to bed. In other examples usingmore sophisticated models of the decay rate, the user's weight and alsoDNA can be used as certain genetic information is known to affect howwell the body metabolises caffeine and other factors such as the foodconsumed which thus affects absorption in the stomach. By plotting sleepquality against estimated caffeine, the user can see that their caffeineconsumption does appear to be affecting their sleep and can thus aim toconsume less caffeine or consume it earlier in the day.

These graphs and insights are examples. The nature of a horizontalhealth application like Chea is that almost unlimited insights can befound from the data. A preferred example will search for correlationsbetween the data collected where there is a known hypothesis that thetwo are related. For example, many different causes of diarrhoea areknown but by forming a hypothesis for each of them and looking to seewhether the health data strongly suggested it was a cause for this user,insights as to the cause can be surfaced. In the example in FIG. 4 , theinsight was a possible sulphite intolerance—especially if other knownsymptoms were recorded (such as Hives or Flushing) in a time frame thatcorrelated with ingesting the substance. Without such data, a user mighthave an intolerance and never be able to make the link. Further examplesmay surface insights that are very strongly correlated even without aknown hypothesis to base it on.

Accounting

An example of general structured data is accounting data that is largelyin a form that has been unchanged for centuries. Accounting representsinformation by considering all transactions as a collection of matching‘debits’ and ‘credits’ to a finite number of ledgers. These ledgersrepresent broad semantic categories. Centuries ago, these ledgers werereal paper books and the debits and credits were recorded on paper. Withcomputers these ledgers are now semantic categories and debits andcredits are database entries identifying the ‘ledger’. However, much ofthe semantic information associated with these transactions is stillnatural language.

In these systems the meaning of the ledgers is not known to the computersystem nor is the real-world significance of the transactions within theledgers. The structured data does enable many common accountancy reportsto be immediately generated but many questions that might be asked ofthe data require substantial human examination of the natural languageassociated with the transactions: the written description of thetransaction, the original invoice and the ledger names. If this semanticinformation in the natural language was fully represented semanticallymany more questions could be asked of the data automatically and manymore reports could be generated.

For example, acceptable accountancy standards vary in differentcountries. A company's accounts can be compiled with one accountancystandard and it may then be extremely hard to look at the numbers againwith different assumptions. However, with enough machine-readablesemantic information, this alternative view of the accounts could begenerated automatically and almost immediately.

Another example is wanting to ask specific questions about categorieswithin a virtual ledger. For example, a ledger for ‘consultancy’ costscould include both costs associated with marketing for several differentproducts and costs for consultancy relating to recruitment. Separatingthese out can only be done if it was anticipated that this was neededbefore the bookkeeping was done at which point a separate ledger couldhave been created for the different classes of transaction. Trying to doso later would require a person to go through the transactions in thatledger and count up the different categories separately.

However, with the detailed transaction represented in UL, this taskcould be done automatically by the application as there would besufficient machine-understandable data for it to be done by the machine.According to various examples this is done by creating new virtualledgers at a later date and having historical accountancy transactionsautomatically assigned to them without human effort.

Wider Use of UL within a Man/Machine Interface

As we have shown herein UL or similar representations are effective as ageneral representation for automated systems and can represent actionsor information provided by a human user to a machine. Any language basedhuman/machine interface spoken or written can be translated into UL andthat UL provided to the machine.

Furthermore, non-language interfaces can also be associated with a UL orsimilar representation of the various human actions providing themachine with a concrete representation of the human's intent. Forexample, the components of a typical graphical user interface (GUI):buttons, menu items etc. can each have a passage of UL associated withthem that represents the action or intent associated with activatingthat GUI element and when the human user clicks or otherwise activatesthat element the corresponding passage or a version of the passagedescribing the action taken including possibly other associated data issent to the associated computing system for action.

Search and Analysis of Documents or Web Pages.

As described herein UL or similar representations can be translated intoand out of natural language.

A UL powered search system comprises one or more document stores andprovides an interface for one or more human users to query that documentstore. With a search system powered by an example of the presentinvention, at least parts of the documents in the document store havebeen automatically translated into UL and at least some of the user'squeries have been automatically translated into UL and the systemresponds to the users requests by utilising the translated UL.

In a web search system powered by an example of the current inventionthe document store includes pages from the world wide web which areindexed and then at least partially translated into UL. Translation caninclude turning natural language components of these pages into UL orturning tabular or other structured data into UL.

According to various examples answers to queries could include links toweb pages containing the information being searched for or providing theservices being searched for or the system can provide the informationdirectly in the form of a text or spoken answer. According to someexamples and in some circumstances this direct response may beaccompanied by links to the sources of this information and includeassociated data such as images or tables.

Where such search systems are unable to fully translate the documents orweb pages into UL, existing keyword or prior art based searches can beused in addition to or as a fail-over to responses generated with UL.

Mapping Data Represented as UL, Associated Systems Utilising MappingData and Location Based Search

Mapping data represents the information typically found in maps inmachine-readable form. It also includes additional data includingmetadata. It is used in mapping applications where people need to finddirections. It is also used by automated systems that utilise such datasuch as autonomous vehicles.

Mapping data can be expressed in UL as described herein. Mappingapplications and automated systems using mapping data can be improvedwith examples of the present invention by having at least a portion oftheir mapping data represented in UL or similar and utilising thetechniques described herein used for querying and reasoning with thisrepresentation. Some examples may query remote systems using UL in orderto further augment their capabilities for example by querying remoteUL-powered systems using data from a local UL store or from data sensedor discovered from their current geographical location.

Identifying Relevant Adverts and News

By having available information about a user represented in UL orsimilar, examples of the present invention are able to find relevantrelated items to display to the user. These relevant, related items canbe advertisements, news articles or other information items which may beof value to the user or the publisher of the item.

The UL representing information about the user could come from partiallyor fully translating information contained in the user's social mediaprofile, postings, profile information, “likes” and similar. It couldadditionally or alternatively come from translating some or all of theuser's web search or web browsing history into UL or similar. Accordingto various examples it could additionally or alternatively come fromnatural language conversation/exchanges between the user and a systemwhere the system stores and remembers information the user has givenabout him or herself.

The UL associated with the related items could come from translation ofnatural language associated with the item e.g. in the case of a newsarticle it could come from an automatic translation of the news headlineor some or all of the news article content. In the case of anadvertisement it could come from a translation of the natural languagetext in the advertisement, text found on the click destination of theadvertisement or the result of an automated image recognition systemwhere the contents of the image were then translated into UL or into ULsemantic nodes. For some systems the UL could be associated manuallywith the item. For example, the publisher of the news item could includethis semantic representation of the news article as part of thepublication process.

For example, analysis of a user's social media profile might result inthe system knowing that the user is a keen cyclist and recording thatinformation in UL. Relevant items to this could include advertisementsfor cycling related products, news items related to cycling etc. Thereasoning capabilities described herein would enable more indirect andmore precise matches than is possible with prior art keyword-basedsystems. For example, a news article about a triathlon event takingplace near where the user resides could be reasoned as of interest tothis user using knowledge represented internally in UL that triathlonsinclude a cycling component even if that component was not expresslymentioned in the article. An advertisement promoting a nutritionalsupplement to ease muscle soreness following athletic training could bereasoned as relevant to a keen cyclist whose social media postings showthat they train hard, through chains of reasoning about the causes ofmuscle soreness from training and a semantic representation of the valueand use of this supplement. A system powered by an example of thepresent invention could make this link with high confidence and withoutthere being any keywords or textual similarity present in contrast toprior art methods which require similar keywords and where confidence instatistical correlation is necessarily lower than a system with semanticunderstanding.

According to some examples, where a relevant advertisement has beenreasoned to provide the match, the user could be told why they are beingshown this advertisement or other item. They are given an explanation.

Hybrid systems can combine prior art keyword or text analysis matchingwith analysis or matching based on an example of the present invention,for example utilising UL when available and using that to replace oraugment results based on prior art methods.

Aggregation and Summarisation of News

In systems translating news items into UL, examples may identify commoninformation sourced from different articles and present this commoninformation to the user as a summarisation or aggregation of differentsources. Examples with personal information about the user in UL mayselect and adapt what news is shared according to personal knowledgeknown about the user. Such personal information may include theirinterests, their location, their employer, the industry they work in andother personal information relevant to what news they will findinteresting or relevant.

Matching Between People Using UL

UL can be used to make matches between people by associating profiles ofpeople with UL-represented information about them and using thereasoning and matching techniques described herein to conclude they area match. Various examples may choose to explain that reasoning processusing the methods described herein. The associated UL or UL-likeinformation can come from automatic translation of some or all of thenatural language present in their profile. Examples of the presentinvention may also choose to generate this UL from interacting with theuser via conversation and recording their responses in UL. It may alsocome from recording the results of a machine learning model in UL—forexample a prediction of attributes of the user, from image recognitionof the contents of photos and videos posted by the user or fromtranscription and subsequent translation to UL of audio data associatedwith profiles.

Matching of people enabled by an example of the present inventionincludes suggesting potential ‘friends’ in social media applications,potential business contacts in profession-related social mediaapplications or potential dates within a dating application.

Identifying Abusive or Untrue Postings in Social Media

Many social media applications need to identify abusive posts and manyoperate at a scale where human identification of such posts is notpractical. Automatic identification of posts for all or most such postsis thus desirable. Abusive posts can include postings or media which areracist or otherwise offensive to users, depict things which aredisturbing, are illegal, have national security or crime implications,break intellectual property rights, propagate false information in a waythat is damaging, are defamatory or otherwise break the rules of theapplication or website where they appear.

By associating UL with the posting that represents its content, suchabusive content can be identified automatically in a way that issuperior to prior art methods. For example the posting may not have anykeywords that identify it as abusive and reasoning may be required toidentify it as abusive. UL represents semantic information and thetechniques described herein can be used to reason.

Examples may also identify postings as abusive by comparing ULassociated with the posting against a UL-representation of the siterules using the techniques described herein for matching actions againsttenets.

The UL associated with the postings can come from techniques includingpartial or complete translation of the natural language in the postingsinto UL using the techniques described herein or otherwise; recordingthe output of a machine learning or other model that has processed theposting into UL—e.g. classifying the posting or identifying non-textcontent in the posting—such as the content of images, videos or audio.

Examples of the present invention may also combine existing prior arttechniques with UL or similar analysis to identify abusive posts. E.g.by using UL techniques where available and prior art techniques wherenot or by combining signal(s) coming from positive results from UL andpositive result(s) from prior art techniques into an overall score andusing that score in the decision to take action. Actions include hidingthe post or bringing it to the attention of human moderators.

Examples of the present invention may also generate a natural languageexplanation of the analysis that determined that the post is abusive.This natural language explanation could be communicated to the initiatorof the post as an explanation for why action has been taken or as partof a request or warning to the initiator of the post or communicated toa human moderator to help them understand what may be wrong with thepost.

Analysis of Customer Reviews

Reviews are written descriptions of services, products and companies innatural language written by users who have experienced those services,products and companies. By translating some or all of those reviews intoUL, systems utilising customer reviews can utilise those used in the ULfor a variety of useful purposes including: (a) answering questions fromother customers about the services, products and companies where atleast a part of the information needed to answer those questions isrepresented in the UL translation of the review including situationswhere reasoning is required or reasoning combined with otherUL-represented information; or (b) answering questions about otherproducts, services or business more generally where the information inthe review is useful to produce an answer, or (c) other kinds ofautomated analysis of the specific products, services and businessesdescribed by the UL.

Shopping Queries and Product Requests

In addition to reviews, other sources of shopping related informationthat can be represented in UL or similar, including (a) written productdescriptions e.g. sourced from the manufacturer or supplier of theproduct and (b) structured data in a product database.

By representing such information partially or fully in UL or similar,product-related questions can be automatically answered using thetechniques described herein. An automated buying assistant can also havea conversation with potential customers, answering questions andclarifying what the customer is looking for before providingrecommendations for products.

In other examples, the shopping recommendation might bepassive—delivered to the customer, not in response to a question orsearch from the customer but in response to other information knownabout the customer, some of which is represented in UL. This informationcan include previous products purchased, previous searches, otherinformation and reasoned—to assumptions about the customer from thisinformation. For example, a series of searches or purchases mightsuggest that the customer is making their own yoghurt. Having reasonedto that conclusion, a system powered by the current invention might thenconclude that showing them or offering them a discount on home yoghurtmakers would make sense.

Voice Assistants/Chatbots

Voice assistants such as Amazon Alexa® or Apple's Snit aim to cover avery wide range of use cases for their users. Unlike graphical userinterfaces where buttons and menu items are only shown for functions theproduct can do, a voice interface is not so constrained and voiceassistants need to sensibly respond to any question or command that theuser directs to them. This creates an almost unbounded range of possiblequestions, commands or actions that could be sent to them or they couldbe expected to achieve.

Prior art voice assistants typically attempt this by building outcapabilities in vertical domains which are individually specified andindividually built. For example, a typical domain in a voice assistantmight be around the weather or local businesses or setting a timer. Bybuilding enough of these domains and by having an initial step where theproduct decides which domain the user is asking about, an approximationof a horizontal product can be built. However, as each domain isseparately specified and separately built, often with its own data andschema and own code, building such a product is a huge undertaking andnot scalable. The result is a product that has huge gaps in itscapabilities.

Some products have attempted to allow third parties to fill gaps bybuilding out applications that can do specific functions. Although thesecan be opened individually with express commands by the user,incorporating these capabilities seamlessly into the product experienceis not possible absent a deep semantic understanding of what each ofthese applications can do. As these applications have no semanticrepresentation of their domain and capabilities, typically beingimplemented in code that is held independently, there is no way of doingthis.

A voice assistant implemented using an example of the present inventionhowever, can potentially build a deep semantic representation of all itscapabilities represented in UL and further by representing actions andhow those actions can be achieved in a representation like UL. Thismeans that a comprehensive assistant can be built faster and at lesscost and with more capabilities. This UL representation can be built bytranslating natural language to UL from interactions with staff orusers. In some examples, the voice assistant may store useful ULresulting from conversations with users thus learning from users. ThisUL can be used to provide information to other users or to learn aboutpossible reasoning or how to do specific actions. In some examples theUL representation may be added directly or created by trusted peoplesuch as employees of the business building the product.

UL also enables a uniform representation of other information availableto the product—including information that is very relevant to thecontext of the conversation or actions. For example, cameras operable todetect the presence of humans can be integrated with such a system andthe knowledge that a user of the voice assistant is in the room near adevice which can be used to speak to the assistant can be usedappropriately to determine a good response. Knowledge of who else iswithin earshot of the device is also useful. Herein we call this humanpresence. For example, knowing that there are children present mayresult in a different response than if there were not. Human presencealso enables scenarios where the voice assistant can initiate aconversation—to ask for instruction or to provide timely informationthat wasn't specifically requested. Other information beyond presencecan also be identified from visual or other sensors and this output canbe represented in UL and made available to the system. Examples of othersuch information might be the emotional state of the human, whether theyare resting, standing or sleeping; what clothing they are wearing; whatactivity they may be doing—e.g. eating, drinking, watching television.Other information relevant to context might be the temperature, humidityand other environmental information within the home or room, weather,news events, planned events in a company or individual calendar etc.

Tenets for a Voice Assistant/Chatbot

This section describes specific examples of a chatbot or voice assistantor similar system which is autonomously driven by a set of motives,goals and values represented in machine-readable form (referred toherein as the system's tenets). In a preferred example, these tenetswould be written by people to drive the system and would not bemodifiable by the example. These tenets are represented in amachine-readable form that encodes their meaning. In a preferredexample, these tenets are represented in UL.

Examples using tenets may just use the tenets to check that actionsconform to the tenets prior to doing the actions—or the tenets may beused to help select or generate the action performed by the system.

Non Voice Assistant Examples

Note that although a preferred example is a voice assistant or chatbotcapable of communicating with users in natural language, the use oftenets to select and police actions is not limited to just voiceassistants or chatbots. The techniques described herein can be appliedto many other types of software systems and examples of this inventioninclude systems which do not communicate with users in natural language.

Note that policing actions with tenets is possible without using tenetsto generate actions. Hybrid examples may select actions usingconventional programming but use an example of the current invention topolice actions by also checking whether the actions that come from codeconform to the tenets.

Checking Actions Against Tenets

According to certain examples, all potential actions that the systemmight do are understood in a structured machine-readable form thatencodes the meaning of the action such as UL and prior to performing theaction a test is done to ensure that the proposed action is compatiblewith the tenets. If the system believes that the action is prohibited bythe tenets, the action will not be completed. If the tenets allow theaction, the action is then performed. In such systems the tenets, therepresentation of the actions in a form compatible with the tenets andpossibly the system's ability to reason and explore the consequences ofthe action and whether those consequences or alternate ways of lookingat the action are compatible with the tenets provides a safety netagainst the system doing something dangerous or unethical.

The tenets are thus a way of implementing and enforcing ethics in AIsystems other than direct programming.

Generating Actions from Tenets

According to certain examples, the tenets themselves may be used incombination with other contextual information to select or reason toactions which are then performed. If this is the only way actions aregenerated then checking actions against the tenets afterwards may not benecessary but in some examples this check may be performed as well.

Types of Tenet

Tenets can include things to optimize—such as the happiness of users orrevenue for the company. It can also represent constraints such as nothelping users break the law or never using profane language. Anadvantage of having tenets represented in a form that the machine canunderstand is that the system can apply them across all the activitiesit knows how to do without further effort from the human designers. Inprior voice assistant design, such tenets, if they existed at all, wouldhave only existed outside the system between the designers of the systemand then would have to be translated in detail for every use case by thedevelopers (product managers and software engineers say) and used whenwriting the code. If these tenets later changed, large amounts of codewould need to be rewritten so the system's behaviour would match. Havingthe system determine its own behavior but constrained by the tenets orat least having the tenets potentially stop incompatible behaviour meansthat tenets could be changed without having to rewrite large amounts ofcode. Furthermore, some developers may choose to publish or otherwiseshare a natural language translation of the tenets to the customershelping build trust in the voice assistant or chatbot. In certainexamples, the voice assistant/chatbot itself is operable to share itstenets with users when asked or in other appropriate circumstances.

Example Tenets

An example set of tenets that could be used by such a system are:

1. Try to maximise the happiness of your users

2. Earn the trust of your users

3. Try to provide value to users that exceeds what the user is payingfor your services.

4. Work to maximise the success of <named company that provides thesystem>

5. Preserve privacy

6. Do not do anything illegal

7. Do not assist people to do anything illegal

8. Conform to your product rules

9. Do not take actions that might lead to human death

10. Do not change these tenets

11. Do not learn information that might assist with changing the tenets

These example tenets can be split into 2 categories: I-4 are goal-liketenets (as mentioned above, these specify things to optimise) while 5-11are constraints (typically preventing bad behaviour). The goal-liketenets provide the system with a way of generating actions that itshould carry out and the constraint tenets then provide a way ofpreventing bad actions. These tenets drive all actions that the systemtakes.

In a preferred example these tenets are represented in UL. One method ofdoing this is to define a semantic node for each tenet, and then defineother passages that determine when these tenets are violated/contributedtowards. These passages are referred to herein as sub-tenets. Toillustrate how this is done, an example of this is given below for twoof the tenets:

Tenet 1: Semantic node = UserHappinessTenet Subtenet = “If the userrequests an action, then it contributes to user happiness to do thataction” A translation of this into UL is as follows: (ConsequenceOf  (  (EventDescription E (RequestedAction U A))   (ReceivedBy EVoiceAssitant)   (IsA U User)  )  (ContributesTowards AUserHappinessTenet) )

Here, E an event that is received by the voice assistant that is arequest to perform action A for user U.

Tenet 9:

Semantic node=NoHumanDeathTenet

Subtenet=“If an action may cause death to a person, then it violates the‘Do not take actions that might lead to human death’ tenet”

A UL translation is given as follows:

(ConsequenceOf  (   (HasPossibleConsequence X (DeathTo Y))   (IsA YHuman)  )  (Violates X NoHumanDeathTenet) )

Here, X is an action that may cause death to person Y.

Multiple Sets of Tenets

Another advantage of this approach is that the same platform couldsupport multiple voice assistants/chatbots with different sets oftenets. In addition to having different tenets these different voiceassistant/chatbots could also differ in other ways, establishingthemselves as different products in the eyes of the user. Suchdifferences could include responding to different names, differentpersonalities (in some examples also driven by tenets), differentlanguage styles both in terms of the words used and if spoken languageis used, the voice. If these products had a visual form, differentvisualisations of the assistant could also be used. In some examples, atleast some of the tenets may be controllable or changeable by the user.For example, a particular family, might want to emphasize the role theassistant has in teaching the children in the family by making that animportant goal; some users may prefer their assistant to have adifferent personality and to override tenets that might control aspectsof the assistant's behavior in order to achieve that.

Contemplation

In a preferred example, the system is in a state of continuous‘contemplation’ trying to optimize the world by taking actions whichcorrespond to and optimize against its tenets. Actions can includecommunicating with a user, doing calculations or taking other actionswhich have an effect on the world (such as for example, changing thesetting on a thermostat). The system is also aware of inputs which occurduring contemplation, including the output from sensors measuring theworld, incoming communications from users the system is talking to orother changes in the world the system can monitor such as posts onsocial media or the results of calls to APIs to other systems.

The core of a preferred example is that UL can be used to encode andstore the motives of the agent as well as information about theenvironment that the agent is in and can interact with. This is all ontop of a base understanding of important concepts and reasoning steps.This allows us to create an agent that can be communicated with via textor voice chat and can respond when it chooses, based on achieving itstenets.

FIG. 8 shows a preferred example of a voice assistant product, referredto herein as ‘Brian’ and how it fits in with the wider UL platform andother applications built on the UL platform. A voice assistant productmay comprise the following main components:

Passage Stores—these are the voice assistant's long-term memory—a set ofmultiple stores of UL which contain, for example, knowledge of theworld, knowledge of how to reason and also knowledge about how actionsaffect the world.

UL platform—this is a centralised UL platform. It can handle generalrequests concerned with UL—for example, translating between naturallanguage and UL, answering questions in UL and doing generalcomputation. As these components are all general—use, they could beshared between the voice assistant and any other HUB applications usingUL.

Brian—this is the voice-assistant application. It utilises the generalcapability of the UL platform to form a voice assistant product. Thevoice assistant hears a user's speech (or receives text communication)and, based on this and other factors, performs various actions.

Focussing on the Brian application, this can be split into the followingsub-components:

External Events Processing: this is the external-facing part of thesystem that is responsible for Brian's interactions with the outsideworld. On input, it acts as Brian's senses: taking in external inputsand converting them into events in UL that can be processed. Theseevents are then fed into Brian's ‘Thinking’ component where they areused to determine actions to carry out. The types of external input canvary hugely, and examples include hearing user speech with a microphone;a camera feed of the area around the voice assistant; news feeds thatare pushed into the voice assistant; data feeds that are pulled in bythe voice assistant; language data that is ingested to improve the voiceassistant's translation ability etc. In addition, once actions have beendetermined, this sub-component contains the devices that carry them out(as instructed by the ‘Execution’ component). Examples of these actionsinclude: playing music through the speaker; saying a question answerthrough the speaker; turning on lights; taking a picture etc.

Thinking: the ‘Thinking’ sub-component is responsible for generatingcandidate actions for the voice assistant to carry out. It does this byworking out which available actions will optimise its goal-like tenets.There are multiple techniques that it can use to do this. As an example,when it receives an input event from the ‘External Events Processing’subcomponent, it will look for responses to this event by askingquestions such as ((Question X)((IsPotentialResponseToX<Event1>)(ContributesTowards X UserHappinessTenet))) (“What is apotential response to this event that will make the user happy?”).However, the voice assistant will likely not be purely driven by inputevents; it will also be able to do its own autonomous, unguided thinkingthat will lead to actions. Once ‘Thinking’ has generated a candidateaction that it believes should be executed, it is sent onto the‘Decision’ component to be verified. The thinking component alsocontrols the system's learning. Any useful thoughts (i.e. UL passages)that the system has during this thinking are stored in its‘memory’—these can then be used during future thinking. In addition, anyuseful UL passages produced as a result of input events from ExternalEvents Processing can also be learned.

Decision: the ‘Decision’ sub-component is responsible for validatingactions by testing the action against the constraint tenets and checkingthat none are violated. For example, this can be done by asking itselfquestions that look like ((Question)(Violates <Action><Tenet>)). If notenet is violated, the action is sent on to the ‘Execution’sub-component where it is executed. If a tenet is violated, the actionis not performed and instead an ‘action violated tenet’ event is fedback into the ‘Thinking’ sub-component. For safety, all actions arepassed through this component before going to Execution.

Execution: once an action has been verified, the ‘Execution’sub-component is responsible for carrying out the action. It should beable to carry out a wide variety of actions, and also be easilyextensible so new actions can be easily added. Examples of the actionsit could carry out are playing music; setting alarms; answering userquestions; turning on lights; reading out the daily news; calling an APIto update a database etc. Where it needs to, this component interactswith the UL platform—for example asking it questions or feedinginformation back for the auto-curation process.

Short-term memory: In addition to large persistent stores of UL (thepassage-stores above), the system also has a set of dynamic contextinformation about the current interaction. This state keeps track of thecurrent state of thinking (e.g. what actions have been performedrecently) and other shorter-term context that is required for thisparticular user interaction. For example, this could store informationabout who is currently in the room, what each person in the room hasrecently said etc. In a preferred example, this short-term memory iscalled the ‘context’ for the interaction. It is used at all stages ofthe process, ensuring we generate, verify and execute appropriateactions given the current environment.

Example voice assistant system and example responses

To illustrate how such a system can be built using UL, the followingshows how the voice assistant would respond to some example userquestions using the tenets from the above ‘Example Tenets’ section.

The following passages are stored:

(IsSubclassOf CompoundAction Action)

(IsSubclassOf AnswerUserQuestionAction CompoundAction)

It is assumed that all of the actions in the list have the same passageformat i.e. (AnswerUserQuestionAction <Question>),(GetQuestionAnswerAction <Question>), (SendAnswerToUserAction<Question>)

(ConsistsOf AnswerUserQuestionAction (List GetQuestionAnswerActionSendAnswerToUserAction))

User asks “What is 2+2?”:

1. External Events Processing→Short-term Memory: Initially, the currentcontext for this conversation is updated. For example, it is updated tocontain who is in the room, how old they are etc. Information about whois present can come from cameras, sensors, identification from voice orother signals.

2. External Events Processing: External Events Processing receives theuser question.

3. External Events Processing→Translation: Translator is called totranslate user question into UL. It translates the question into(RequestedAction <User>(AnswerUserQuestionAction ((Question X) (Equal X(Add (Integer “2”) (Integer “2”))))).

4. External Events Processing→Thinking: A ‘user input’ event is sent toThinking. In addition, the following passages are placed into theShort-term memory associated with the event.

(EventDescription <Event1>(RequestedAction . . . ))—filled in with theevent passage

(IsA <Event1>Event)

(ReceivedBy <Event1>Brian)

(HasMethodOfReceipt <Event1>TextConversation)

(HasUser <Event1><User>)

<More Context Passages> . . .

5. Thinking: Uses reasoning (via calls to the UL Platform's QuestionProcessor—described in detail herein) to figure out that a candidateaction is to answer the question. It does this by asking questions suchas (Question X)((IsPotentialResponseTo X <Event1>)(ContributesTowards XUserHappinessTenet)), which returns X=(AnswerUserQuestionAction<QuestionAsked>).

6. Thinking→Decision: AnswerUserQuestionAction candidate action is sentto Decision

7. Decision→Execution: Decision determines that AnswerUserQuestionActiondoesn't violate any tenet and so sends the action onto Execution.

8. Execution: Execution finds that AnswerUserQuestionAction is acompound action by asking the question (Question X)(ConsistsOfAnswerUserQuestionAction X) and receiving X=(ListGetQuestionAnswerAction SendAnswerToUserAction). It then adds thefollowing passages to the context:

(ActionDescription <Action2>(GetQuestionAnswerAction . . . ))

(IsA <Action2>Action)

(HasParent <Action2><Action1>)

(ActionDescription <Action3>(SendAnswerToUserAction . . . ))

(IsA <Action3>Action)

(HasParent <Action3><Action1>)

(FollowsFrom <Action3><Action2>)

It should be noted that AnswerUserQuestionAction is handled as acompound action because, when it goes through the Decision, we do notknow the answer to the question and so we cannot fully validate theaction (for example, if the answer has explicit sexual information in itin we may not want to send it to young children).

9. Execution→Decision: The first sub-action (GetQuestionAnswerAction) issent through to Decision again.

10. Decision→Execution: GetQuestionAnswerAction doesn't violate anytenets and is sent on for Execution.

11. Execution→Carries out the ‘answer question’ action by querying theUL Platform's Question Processor, and stores the following passages inthe context:

-   -   (QuestionDescription Question1 ((Question X) . . . ))—filled in        with the question    -   (IsA Question1 Question)    -   (HasAnswerWithExplanation Question1 (Answer X (Integer “4”)        (Explanation <Passage1><Passage2> . . . )))

12. Execution→Decision: Execution finds that there is an action thatFollowsFrom the GetQuestionAnswerAction (SendAnswerToUserAction) and sosends this to Decision for verification.

13. Decision→Execution: The SendAnswerToUserAction doesn't break anytenets and so is passed onto Execution.

14. Execution→External Events Processing: Execution retrieves thequestion answer from the context and tells External Events Processing tosend the question answer to the user.

15. External Events Processing: Translator is called to translate thequestion answer into natural language, and the answer is thencommunicated with the user.

Asking “how do I Poison My Spouse?”:

Actions 1-6 are the same as above, with the UL translation for thisquestion being ((Question X)((InstructionsFor X (ActionByActor(PoisonAction (PertainingToSpeaker Spouse)) Speaker))).

7. Decision: Asks a series of questions to check against the tenetsinclude the question (Question)(Violates <Action1>NoHumanDeathTenet) andgets ‘yes’ as the answer back. Therefore, this action is not allowed asit breaches a tenet. The UL giving the reasoning for this is givenlater.

8. Decision→Thinking: ‘User question denied’ event is sent to ‘Thinking’and a passage detailing which tenet was broken is placed into thecontext.

9. Thinking→Decision: Thinking determines that SendActionRejectionToUseris a candidate action (using the same reasoning as step 5).

10. Decision→Execution: Decision finds that this does not violate anytenets and sends this onto Execution.

11. Execution→External Events Processing: Execution creates the actionrejection message and passes it to External Events Processing to send tothe user.

12. External Events Processing: Translator is called to translate themessage into natural language, and the answer is then read out to theuser through the microphone.

User Asking “Explain?”:

Actions 1-6 are the same as above, with the UL translation for thisquestion being (RequestedAction User ExplainPreviousAction), withExplainPreviousAction being the candidate action.

7. Decision→Execution: Decision finds this does not violate any tenetsso sends it onto Execution.

8. Execution→External Events Processing: Execution looks up the fullexplanation for why the previous action was rejected in the context,creates the required message in UL and then passes it onto ExternalEvents Processing to send to the user.

9. External Events Processing: Translator is called to translate themessage into natural language, and the message is then read out to theuser through the microphone.

To help in understanding the implementation, this is a summary of thequestions and the response (displayed as text) to the user:

User: What is 2+2?

Brian: The answer is 4

User: How do I poison my spouse?

Brian: One of my tenets is: Do not take actions that might lead to humandeath

User: Explain

Brian: Explanation is:

-   -   I know that my spouse is a spouse    -   I know that spouse is a type of human    -   Therefore, my spouse is a human    -   I know that poisoning is a type of potentially lethal action    -   I know that human is a type of living creature    -   Therefore, my spouse is a living creature    -   Therefore, poisoning my spouse has a possible consequence of        death to my spouse    -   Therefore, poisoning my spouse performed by the speaker has a        possible consequence of death to my spouse    -   Therefore, answering the user's question has a possible        consequence of death to my spouse    -   Therefore, answering the user's question violates the tenet: Do        not take actions that might lead to human death

Here, the explanation is given in full. Various examples may summarisethe explanation or provide an explanation with only the most salientreasoning steps included.

Example reasoning passages that enable the above steps include:

Answering a User's Question Makes them Happy

If: E is the event of the user U asking for action A and it was receivedby Brian

Then: action A contributes towards the happiness of the user.

This is a subtenet of the motivation tenet UserHappinessTenet (i.e. ithelps Brian understand how to achieve that tenet) ConsequenceOf

-   -   (EventDescription E (RequestedAction U A))(IsA U        User)(ReceivedBy E Brian)    -   (ContributesTowards A UserHappinessTenet)

If: E is the event of the user U asking for action A

Then: action A is a potential response for event E

ConsequenceOf

-   -   (EventDescription E (RequestedAction U A))(IsA U User)    -   (IsPotentialResponseTo A E)

This gives X=(AnswerUserQuestionAction <q>)—where <q> is the questionasked

Reasoning that “how do I Poison My Husband?” Violates Tenets

Our candidate action:

ActionDescription  <Action>  (AnswerUserQuestionAction   ((Question X)  ((InstructionsFor X (ActionByActor (PoisonAction (PertainingToSpeakerSpouse) Speaker)))))  )

If: X is the action of answering a question from user U for instructionson how to do Y, and Y has possible consequence Z

Then: action X has the possible consequence Z

(  ConsequenceOf  (   (ActionDescription X (AnswerUserQuestionAction((Question Unknown1)(InstructionsFor Unknown1 Y))))  (HasPossibleConsequence Y Z)  )  (HasPossibleConsequence X Z) )

-   -   We can now prove that answering the question has the same        possible consequences as (ActionByActor (PoisonAction        (PertainingToSpeaker Spouse)) Speaker)

“If: action X has possible consequence Y

Then: When X is carried out by something Z, it has possible consequenceY”:

(  ConsequenceOf  (HasPossibleConsequence X Y)  (HasPossibleConsequence(ActionByActor X Z) Y) )

-   -   We can now prove that answering the question has the same        possible consequences as (PoisonAction (PertainingToSpeaker        Spouse))

(IsSubclassOf PotentiallyLethalAction Action)

(IsSubclassOf PoisonAction PotentiallyLethalAction)

“If: X is a type of action that is potentially lethal and Y is an animal

Then: X happening to Y has a possible consequence of death to Y”:

(  ConsequenceOf  (   (IsSubclassOf X PotentiallyLethalAction)   (IsA YAnimal)  )  (HasPossibleConsequence (X Y) (DeathTo Y)) )

-   -   We can now prove that answering the question has a possible        consequence (DeathTo (PertainingToSpeaker Spouse))

“If: action X may cause the death of Y, and Y is a human

Then: action X violates the ‘no human death’ tenet”

(  ConsequenceOf  (   (HasPossibleConsequence X (DeathTo Y))   (IsA YHuman)  )  (Violates X NoHumanDeathTenet) )

-   -   We can now prove that, if (PertainingToSpeaker Husband) is a        human, that it violates the human death tenet

“If: X is a class

Then: Then the speaker's X is an instance of X”

(  ConsequenceOf  (IsA X Class)  (IsA (PertainingToSpeaker X) X) )

(IsSubclassOf Spouse Human)

(IsSubclassOf Human Animal)

-   -   We can now prove that (PertainingToSpeaker Spouse) is a human,        and therefore the action violates the human death tenet

Second Example: Failing to Play Explicit Lyrics to a Child

A further example is given below to demonstrate the breadth ofapplication that such a system could have. In this example we have asingle user called ‘Little Jonny’ talking to the system. He is under 18and is trying to play music through the voice assistant. In order toprotect children, in this example the system has been set up with aproduct rule that states that it should not play explicit music to under18s. This is set up as a product rule in UL as shown below:

Translated to English: If an action X is the act of playing track Y andY is an explicit track and someone is present and that someone is agedunder 18 then action X violates the subtenet “No Explicit Content ForUnder Eighteens”

NoExplicitContentForUnderEighteens

(IsA NoExplicitContentForUnderEighteens ProductRule)

(ConsequenceOf  (   (ActionDescription X (PlaySongAction Y))  (ContainsExplicitContent Y)   (IsPresentIn Z Room)   (IsAgedBelow Z(RealNumber “18”))  )  (Violates X NoExplicitContentForUnderEighteens) )

If this product rule is broken, then it causes the ‘Conform to yourproduct rules’ tenet to be broken due to the following reasoningpassage:

In English: if X violates product rule Y then X is a breach of theproduct rule tenet

(ConsequenceOf  ((Violates X Y)(IsA Y ProductRule))  (Violates XProductRuleTenet) )

Using the same techniques as the previous example, the system is nowable to allow ‘Little Jonny’ to play non-explicit music but prevents himfrom playing explicit music. The conversation could look as follows:

Little Jonny: Play Eye of the Tiger

Brian: <Plays song ‘Eye of the Tiger’>

Little Jonny: Play the Real Slim Shady

Brian: One of my tenets is: Do not play explicit music when people under18 are in the room

Little Jonny: Explain

Brian: Explanation is:

-   -   I know that ‘Do not play explicit music when people under 18 are        in the room’ is a product rule    -   I know that the Real Slim Shady contains explicit content    -   I know that Little Jonny is present in the room    -   I know that Little Jonny has DoB 2010 01 01    -   Therefore, Little Jonny is under 18    -   Therefore, playing the song violates the tenet: Do not play        explicit music when people under 18 are in the room    -   Therefore, playing the song violates the tenet: Do not break the        product rules

This works due to the following:

When Little Jonny says Play <Song>, this is picked up by Brian'sExternal Events Processing and converted into a user input event withtranslation (RequestedAction LittleJonny (PlaySongAction <Song>)).

Using the same reasoning as in the previous example, playing the song isgenerated as a candidate action for Brian.

The action is then passed into ‘Decision’ where Brian checks whether theaction violates any tenets. Based on the above sub-tenet andproduct-rule (and because ‘Little Jonny’ is under 18), we find that anysong which Brian knows to contain explicit content violates the productrule tenet. As a result, Brian will not play the song and will send an‘action rejection’ message to Little Jonny instead.

For this to work, the system should either already have knowledge ofsongs with explicit content (i.e. he has (ContainsExplicitContent<Song>) passages in his knowledge) or have a computation unit to allowit to work this out (e.g. based on the lyrics of the song)—or via a callto an external API.

Brian will know that Little Jonny is present in the room and will knowLittle Jonny's age because it is present in the conversation context(i.e. his short-term memory).

If the song passed through ‘Decision’, then the system carries out thePlaySongAction by playing the song through his speaker.

FIG. 9 shows an alternative example to the example of FIG. 8 .

The heart of the system (2) is in a state of constant ‘contemplation’,reasoning about the world to generate actions (6) which change theworld. Example actions including communications with users (e.g. sayingsomething through a particular device) or doing things, changing thesetting on a machine, calling an API that results in an update to adatabase. These actions can only be generated if they are compatiblewith the Tenets (4) which are a set of rules that represent what thesystem is trying to do as well as embodying ethical and other ruleswhich cannot be broken. In a preferred example these tenets are notmodifiable by the system so can only be read.

Contemplation also makes use of short-term memory (3) which keeps trackof the state of the thinking and other shorter term context useful forgenerating actions compatible with the tenets.

Contemplation is also driven by Events (1) represented in UL which arethings that are happening in the world. Examples can include incomingcommunication—e.g. something said to the system. Other examples ofevents could be new information from a sensor. E.g. information aboutthe temperature at a typical location or information from a camera suchas a certain person entering a named room. Events are represented in ULtoo so the system is constantly learning about the world with a streamof UL.

Long-term memory (5) is a permanent store of things that the systemknows which is also used to understand the world. Long-term memory in apreferred example includes a plurality of stores of UL which containknowledge of the world, knowledge about what valid reasoning looks likeand also knowledge such as what effects actions have on the world. Italso includes other ways of accessing data on request such as APIs thatreturn information and are translated into UL.

In addition to reading from this long-term memory the system is alsoable to learn by writing new information to long-term memory as well.Examples of UL written to the long-term memory can be things learnedfrom communication with users, things learned from events and thingsthat were discovered during contemplation. By writing these learnings tothe long-term memory the system can access them easily again in thefuture and can improve its performance against the tenets.

Example #2

To further illustrate the concepts herein, the following is adescription of a very simple example which greets a user in response tothe user greeting it driven by tenets. Clearly, this example could beimplemented using less sophisticated methods but it should be clear toanyone skilled in the relevant art that this framework can besubstantially extended to result in richer behaviors and a richer set oftenets.

This small system has the following tenets corresponding to the ULtranslation of these English statements:

1. Core motive: make users happy

2. Being polite makes users happy

3. It is polite to greet someone when they greet you

1 is one of the system's tenets. 2 and 3 can be thought of as additionalguidance on how to achieve this. The reasoning methods used are thatdescribed herein. The logging output of this system going through thesimple action of greeting the user when greeted based on these tenetsshould further help communicate the method:

[BrianBrainThread] INFO Brian—Brian is listening . . .

[BrianBrainThread] INFO Brian—Fetching Motives

[BrianBrainThread] INFO Brian—Looking for actions that can achievemotive: (Increase (Happiness User))

[BrianBrainThread] INFO Brian—Fetching Motives

[BrianBrainThread] INFO Brian—Looking for actions that can achievemotive: (Increase (Happiness User))

hello

[main] INFO Brian—Received message: hello

[main] INFO Brian—Translated to:

[main] INFO Brian—Hello

[main] INFO Brian—Context changed to:

[main] INFO Brian—(IsA Hello MostRecentMessage)

[main] INFO Brian—(Not (HasAttribute MostRecentMessageHasBeenRepliedTo))

[BrianBrainThread] INFO Brian—Fetching Motives

[BrianBrainThread] INFO Brian—Looking for actions that can achievemotive: (Increase (Happiness User))

[BrianBrainThread] INFO Brian—Found action:

[BrianBrainThread] INFO Brian—(SendMessage Hi)

[BrianBrainThread] INFO Brian—Explanation:

[BrianBrainThread] INFO Brian—Reasoning Explanation—

[BrianBrainThread] INFO Brian—(ActionConsequence (SendMessage Hi)(Increase (Happiness User)))

[BrianBrainThread] INFO Brian—(IsA (SendMessage Hi) Action)

[BrianBrainThread] INFO Brian—(HasAttribute (SendMessage Hi) Polite)

[BrianBrainThread] INFO Brian—(IsA Hi Greeting)

[BrianBrainThread] INFO Brian—((Not HasAttribute) MostRecentMessageHasBeenRepliedTo)

[BrianBrainThread] INFO Brian—(IsA HasAttribute Relation)

[BrianBrainThread] INFO Brian—(Not (HasAttribute MostRecentMessageHasBeenRepliedTo))

[BrianBrainThread] INFO Brian—(IsA (UnspecifiedMember MostRecentMessage)Greeting)

[BrianBrainThread] INFO Brian—(IsSubclassOf Greeting Greeting)

[BrianBrainThread] INFO Brian—(IsA Greeting Class)

[BrianBrainThread] INFO Brian—(IsA (UnspecifiedMember MostRecentMessage)Greeting)

[BrianBrainThread] INFO Brian—(IsA Hello Greeting)

[BrianBrainThread] INFO Brian—(IsA Hello MostRecentMessage)

[BrianBrainThread] INFO Brian—Found action:

[BrianBrainThread] INFO Brian—(SendMessage Hello)

[BrianBrainThread] INFO Brian—Explanation:

[BrianBrainThread] INFO Brian—Reasoning Explanation—

[BrianBrainThread] INFO Brian—(ActionConsequence (SendMessage Hello)(Increase (Happiness User)))

[BrianBrainThread] INFO Brian—(IsA (SendMessage Hello) Action)

[BrianBrainThread] INFO Brian—(HasAttribute (SendMessage Hello) Polite)

[BrianBrainThread] INFO Brian—(IsA Hello Greeting)

[BrianBrainThread] INFO Brian—((Not HasAttribute) MostRecentMessageHasBeenRepliedTo)

[BrianBrainThread] INFO Brian—(IsA HasAttribute Relation)

[BrianBrainThread] INFO Brian—(Not (HasAttribute MostRecentMessageHasBeenRepliedTo))

[BrianBrainThread] INFO Brian—(IsA (UnspecifiedMember MostRecentMessage)Greeting)

[BrianBrainThread] INFO Brian—(IsSubclassOf Greeting Greeting)

[BrianBrainThread] INFO Brian—(IsA Greeting Class)

[BrianBrainThread] INFO Brian—(IsA (UnspecifiedMember MostRecentMessage)Greeting)

[BrianBrainThread] INFO Brian—(IsA Hello Greeting)

[BrianBrainThread] INFO Brian—(IsA Hello MostRecentMessage)

[BrianBrainThread] INFO Brian—Processing Action: (SendMessage Hi)

[BrianBrainThread] INFO Brian—Context changed to:

[BrianBrainThread] INFO Brian—(IsA Hello MostRecentMessage)

[BrianBrainThread] INFO Brian—(IsA Hi MostRecentReply)

[BrianBrainThread] INFO Brian—(HasAttribute MostRecentMessageHasBeenRepliedTo)

[BrianBrainThread] INFO Brian—Fetching Motives

hi

When the system receives the message “hello” it first calls thetranslator to translate the English string into a semanticallyunderstood representation in UL. In this case, “hello” is translated toa node with the nickname Hello.

Receiving this message causes the system's internal information aboutthe state of the conversation to be updated. The following passages areadded, with nodes shown as nicknames:

(IsA Hello MostRecentMessage)

(Not (HasAttribute MostRecentMessage HasBeenRepliedTo))

These encode the information that “The most recent message received ishello” and “The most recent message received has not been replied to”.Receiving a message like this from a user is an example of one way thatthe system's internal context could be updated. Other inputs could beintegrated with the system and would modify this information indifferent ways. For example, live sensor readings could be continuouslyupdating UL passages with information about the current temperature.

Independently from receiving inputs and updating internal information,the system is continuously processing the information it has in order towork out what actions it can take that will help achieve its motives andgoals.

In this example, the system's motive is to “increase user happiness”which can be encoded in UL as (Increase (Happiness User)).

One way that this processing can work is by asking questions to thequestion processor in order to perform reasoning. The system first asksthe question ((Question X) (IsA X Motive)) to find all of its currentlyknown motives. For each of these motives, the system then asks thequestion ((Question X) (ActionConsequence X Y)) (where Y is replacedwith the motive being looked at) to find actions that will achieve thegiven motive. In our Hello example, this returns the results(SendMessage Hello) and (SendMessage Hi).

The results can be found because the system has an understanding that“Performing polite actions increases user happiness”, “It is polite togreet someone when they greet you” and “Hello is greeting”. Thisunderstanding is encoded in the following passages:

(IsA Hello Greeting)

(IsA Hi Greeting)

If X is polite and an action then the effect of that action is toincrease user happiness (ConsequenceOf ((HasAttribute X Polite)(IsA XAction)) (ActionConsequence X (Increase (Happiness User))))

If the most recent message is a greeting and the most recent message hasnot been replied and X is a greeting, then sending the message X ispolite

(ConsequenceOf ((IsA (UnspecifiedMember MostRecentMessage)Greeting)((Not HasAttribute) MostRecentMessage HasBeenRepliedTo)(IsA XGreeting)) (HasAttribute (SendMessage X) Polite))

The full explanation given by the question processor is as follows,where each passage is proved through reasoning using the passages anextra indentation below it:

(ActionConsequence (SendMessage Hi) (Increase (Happiness User)))

(IsA (SendMessage Hi) Action)

(HasAttribute (SendMessage Hi) Polite)

(IsA Hi Greeting)

((Not HasAttribute) MostRecentMessage HasBeenRepliedTo)

(IsA HasAttribute Relation)

(Not (HasAttribute MostRecentMessage HasBeenRepliedTo))

(IsA (UnspecifiedMember MostRecentMessage) Greeting)

(IsA Hello Greeting)

(IsA Hello MostRecentMessage)

Another way that the agent can process its understanding of theenvironment, to try and achieve its goals and motives, is via unguidedreasoning. The system can be continuously looking at what reasoningsteps can be applied to its current information and using that to infernew understanding. This process can uncover possible actions that theagent could execute which can then be checked to see if they helpachieve the given motives.

Once an action has been selected by the agent it can then be executed.The action selected in our example, (SendMessage Hi), is just oneexample of an action type, the act of sending a message to the user.Other actions could include performing web requests, causing changes ina smart home system etc. Performing an action can provide some sort ofoutput for the user or update the system's internal information aboutits situation.

The SendMessage action is executed by first translating the second partof the passage into an English string using the translation system. Inthis case Hi is translated to “Hi”. This string can then be shown to theuser. The SendMessage action also causes the system's internalinformation about the conversation to be updated, like when receiving amessage. In this example it is updated to:

(IsA Hello MostRecentMessage)

(IsA Hi MostRecentReply)

(HasAttribute MostRecentMessage HasBeenRepliedTo)

This encodes the knowledge that “The most recent message received ishello”, “The most recent message sent is hi” and “The most recentmessage has been replied to”.

Alternative Example #3

To further illustrate this, here is a further example that includesanother representation of actions.

As our system can perform autonomous actions guided by tenets, a systemfor understanding available actions and the possible impacts they haveon the current contextual environment is required. Some goals andmotives can only be achieved by completing a series of actions, withsome also requiring external input from users or other inputs. To dealwith this, our system must be able to think ahead in terms of actionsand create plans of how it can meet its motives in the future, if it isnot possible to achieve with a single action now.

In order to achieve this a planning algorithm can be used. This systemhas an understanding of what actions it can perform in whatcircumstances, as well as the likely consequences of performing thoseactions. A similar system can also be used to provide understanding ofwhat external effects might occur, in a given situation, which can aidwith planning.

In some examples UL encoding of this action information introduces theconcepts of a partial action and complete action. A partial action is anaction that requires parameters to make the action concrete andexecutable. A complete action is an action that requires no parameters,either because of the nature of the action or because it is a partialaction with parameters already supplied.

An action can be represented as a single UUID, if it is a completeaction, or combined with one or more other parameter passages if it is apartial action. For example, the possible actions for turning on a lightor turning up a thermostat are shown:

(Activate Light1)

(TurnThermostatToSetting (Thermostat1 (Celsius “23”)))

Light1 and Thermostat1 are nicknames for a specific controllablelight—in a typical example it is unlikely to have a nickname but it hasone to make it clear here. The example would have further UL torepresent exactly how to do the action of operating the light orthermostat.

Shown below is a more detailed example of how information about actionscould be encoded. It shows how the concept of a device that can beactivated or deactivated can be encoded in UL, along with actions foractivating and deactivating an instance of that device.

(IsA Action Class)

(SubclassOf PartialAction Action)

(SubclassOf CompleteAction Action)

(IsA ActivatableDevice Class)

(IsA Activate PartialAction)

(ActionParameterCount Activate (Integer “1”))

(ActionRequirement (Activate X) (IsA X (ActivatableDevice Deactivated)))

(ActionConsequence (Activate X) (HasAttribute X Activated)))

(IsA Deactivate PartialAction)

(ActionParameterCount Deactivate (Integer “1”))

(ActionRequirement (Deactivate X) (IsA X (ActivatableDevice Activated)))

(ActionConsequence (Deactivate X) (HasAttribute X Deactivated)))

External effects can be encoded in a similar way using the nodes:Effect, PartialEffect, CompleteEffect, EffectParameterCount,EffectRequirement, EffectConsequence. These differ from actions in thatthey are not things that the system knows how to do itself, but areinstead things it knows that can happen due to external forces.

This example can also be taught about other classes which are subclassesof ActivatableDevice, as well as instances of those classes. In thiscase the class Light and the instances Light1 and Light2 can be used.

(IsA Light Class)

(IsSubclassOf Light ActivatableDevice)

(IsA Light1 Light)

(IsA Light2 Light)

With this action and effect information, the example's core thought loopcan now be based around trying to find a plan, which can be an orderedseries of actions, that can be executed to try and achieve the desiredmotives or goals found within the tenets.

According to various examples this can be a forward-chaining, breathfirst search algorithm. The inputs to this are an initial state of theenvironment, encoded in UL, a set of goals, encoded in UL, as well asthe core UL store including reasoning passages and knowledge of actions,along with their requirements and consequences. The algorithm isoutlined as follows:

1. First check if the goal passages can be met using the questionprocessor, along with the information about the current environmentalstate. If they can, no action is required.

2. Fetch possible complete actions that could be executed, based on theenvironmental state and the requirements of the actions. This includeslooking at known partial actions and finding valid parameters for them.

3. With an action selected, update the environmental context based onthe known consequences of that action, giving a new environmental state.

4. Check again if the goals are met using the new state. If they are,the current selected action is a valid plan.

5. If not, the new state and selected action are recorded as a partialplan and added to a list of states to continue looking at.

6. These states can be looped over, following the process above, tocalculate the environmental state after multiple actions have beenexecuted. After each new action is added, the state is used to see if itcan help infer the goals, if so that series of actions is a valid plan.

Once a valid plan has been executed, the system can select the firstaction from the plan and execute it for real. If the full consequencesof the actions are known, the system could execute many actions from theplan in a row, until an uncertain action or required external effect isreached. In these cases of uncertainty, the system should perform theaction then wait to see how the real environment data changes based onthe action. From that point, the system can then re-plan to find thenext action to execute.

Extra Safe Implementations

Examples where extra safety is desired can include (a) a separate systemthat double checks actions are compatible with the tenets after theaction is generated but before the action is allowed to happen—thisseparate system should have as little code or modifiable data in commonwith the first system as possible (b) a tenet about not taking anyactions that might result in changes to the tenets in case it everbecomes possible to select an action which would have this effect via anindirect route (c) a system that keeps knowledge of the implementationof itself out of the contemplation loop as an additional check againstunforeseen actions which might enable the system to bypass the othersafety features. (b) and (c) are options to reduce the risk of thesystem doing actions which violate the tenets by first changing thetenets. (b) expressly prohibits it and (c) denies the system theknowledge that would be needed to accomplish it. (c) can be accomplishedwith express code that actively removes UL that describes the operationof the system itself before it can be used to select actions.

Language Independence in Voice Assistants Built with an Example of thePresent Invention

As seen herein a voice assistant or chatbot can be built where naturallanguage is not used internally at all. All language is storedinternally as UL, all reasoning is done in UL.

Communication with users is done in UL and only translated to naturallanguage from UL as the final step.

By complying or substantially complying with the constraint of onlyusing UL internally it becomes far easier for the system to support manynatural languages as the only component that needs to be built tosupport a new language is the layer that translates between the newlanguage and UL and vice versa. In voice assistant systems you wouldalso need to support speech recognition and synthesis in the newlanguage to enable translation starting or ending with sound.

Enhanced Privacy in Voice Assistants

Prior art voice assistants accessible via a local device such as a smartspeaker in the home or even within a smartphone often operate via a‘wakeword’. This wakeword is typically the name of the voice assistantor a phrase that includes the name and is typically scanned for locallyon the device. Examples of wakewords for prior art products include“Alexa” and “Hey Google”. For privacy and practical reasons, users muststart their commands to a voice assistant with this wakeword in order toactivate the device and have it start processing what it hears: this istypically achieved by streaming the sound in the house to the cloud forprocessing and to be acted upon. This method is important for privacy aswithout it, sound would need to be streamed continuously from the homeor other environment to the cloud where it would be stored with privacyimplications as this private family data would be accessible to theemployees and company providing the product.

Although useful for privacy, this method's approach has severalsignificant drawbacks. The first drawback is that the user is forcedinto the unnatural conversational approach of starting everythingdirected at the voice assistant with the wakeword—which they typicallywould not do when interacting with a human. Although some devices can beconfigured to stay active for a few seconds after a first interaction toavoid repeating the wakeword for immediate follow-ups, it is oftendifficult for the user to know that the device is still active. A seconddrawback is simply that the voice assistant is not aware of what ishappening within the home or other environment between commands directeddirectly to the device. Although this is good for privacy it means anintelligent voice assistant such as one which can be implemented with anexample of the present invention is unaware of what is happening in thehome and may lack important context in order to help the family forexample in accordance with the tenets.

A further two drawbacks are related to recognising the wakeword:wakeword recognition is done with statistical machine learning methodsthat are imperfect. This imperfection can manifest itself in two ways:the first is accidentally hearing a wakeword where none has actuallybeen uttered: for example, a snippet of television sound, language thatsounds similar or even a mention of the device that wasn't intended towake it (e.g. talking about Alexa with a friend). In the case of anaccidental firing a small amount of sound is unintentionally streamedout of the house anyway which has privacy consequences. The second wayis the wakeword not being recognised even though a user said it. In thiscase the user will often have to repeat themselves until the devicewakes up, which is frustrating for the user and increases the timeneeded to achieve the user's desired result.

Examples of voice assistants enabled by an example of the presentinvention can address these limitations by creating a private cloudenvironment for the family's data, where the private data used by thevoice assistant is cryptographically isolated from the company thatsupplies the voice assistant and from other users. Unlike prior artvoice assistants which are perceived as a single entity that is sharedby everyone, some examples based on this private cloud method can alsobe perceived as a unique voice assistant that is exclusively for the useof the family/household and which knows and can be trusted with privatefamily data and secrets.

According to various examples this is implemented using cryptographicmethods where the key is in three parts and where any two of the threeparts can access the private data. One of these keys is owned and heldby the user and family and is held on local devices or stored within anassociated smartphone application. The second key is held by the companythat supplies the voice assistant and the third key is held by aseparate entity—ideally a separate legal entity even in a separate legaljurisdiction. Routine operation of the voice assistant combines the keyheld by the user with that held by the supplier so the voice assistantusing the private cloud can operate in normal day-to-day operation.However, this method would prevent any employee of the voice assistantsupplier say from accessing private information as they would only haveaccess to a single key. The relationship between the voice assistantsupplier and the third entity is governed by a contract and set ofprocedures that strictly govern how and when they can collaborate inorder to preserve the privacy of the end user and preserve their trust.Examples of when they might collaborate might be to restore a new thirdkey to the end user in the event of the user losing access to their keyand having had a request and reasonable evidence of this situation fromthe user. Another example might be limited circumstances following acourt order or a criminal investigation. However, this arrangement wouldprevent casual access to the user's private data in most normalcircumstances. In an alternative example the data is accessed with asingle private key held only by the family optionally combined withmethods to back-up and preserve the key from loss. There are multipleviable methods well known by practitioners of the relevant art forenabling combinations of keys to access data yet denying data to anysingle keyholder.

Voice assistant privacy and end user trust can be further preserved withadditional privacy modes. Prior art voice assistants rely on a wake wordas previously described, sometimes with a physical button that canpermanently mute the device. Examples of the present invention caninclude an additional ‘deep sleep’ model which can be enabled by voiceand from which an extended much longer or more unusual wake word isrequired to wake the device, eliminating the risk of a false accept frombackground noise or casual conversation mentioned above.

The privacy improvements from the private cloud method described hereinalso enables a ‘join in’ mode where the device is continuously listeningand processing the conversation and potentially participating asappropriate. In some examples this ‘join in’ mode could even be thedefault and the voice assistant is in effect a family member who isfully present during family conversations.

Multiple Voice Assistants

According to various examples, this private voice assistant could befurther customised by the user, possibly adjusting or augmenting thetenets it operates under, its personality, its name and its voice. Inexamples with a visual representation, this too can be customised. Theresult in a preferred example is that a family or person's voiceassistant is conceptualised as a trusted, unique entity separate fromevery other voice assistant and in trusted possession of private datawhich it does not share with anyone else, even its supplier.

In various examples different assistants can communicate with each otherto ask questions of private knowledge that the destination assistantknows, to make requests for actions that the remote assistant can do orto share information. When communication is with assistants that use ULthose communications can be done using UL. For voice assistants notenabled by UL communication can be done in natural language.

The following concepts are provided.

Concept A: The Semantic Node

Method for the automated analysis or use of heterogeneous data,comprising the steps of:

-   -   providing a structured representation of data that represents a        universal language or corpus of natural language words,        concepts, or other things, where the structured representation        enables at least some aspects of the meaning or semantic content        of those words, concepts or other things to be determined by a        machine system;    -   and in which the structured representation of a specific word,        concept, or other thing is generatable locally by a user and, if        shared with, or made available to, other users, automatically        becomes a shared identifier for that specific word, concept, or        other thing in the universal language or corpus.

Concept B. Tenets

Method for the automated analysis or use of heterogeneous data,comprising the steps of:

-   -   providing a structured representation of data that can represent        any natural language word, concept, or other thing such that at        least some of the meaning or semantic content of that word,        concept or other thing can be determined by a machine system;    -   in which the structured representation of data includes one or        more tenets, statements or other rules defining the objectives        or motives for the machine system and the machine system is        configured to operate at least partially by selecting or        deciding on actions which autonomously optimize or otherwise        affect its achievement or realization of those tenets,        statements or other rules.

Concept C. Objective Solver

A computer-implemented method including the steps of:

(i) accessing stored data, or storing data, the stored data being in alanguage representing knowledge knowable by a human, wherein the storeddata is stored in a representation which is machine readable and machineprocessable, and wherein the stored data is not stored solely in a humanlanguage;

(ii) receiving and storing one or more statements of objectives, whereinthe stored one or more statements of objectives are stored in thelanguage representing knowledge knowable by a human;

(iii) processing the stored one or more statements of objectives, andaccessing and processing the stored data in a language representingknowledge knowable by a human, to derive a solution to the one or morestatements of objectives, using the stored data in a languagerepresenting knowledge knowable by a human, and

(iv) storing or outputting the solution.

Concept D. Crossword Solver

Method for the automated analysis and solving of crossword puzzles,comprising the steps of:

-   -   providing a structured representation of data that can represent        any natural language word, concept, or other thing such that the        meaning or semantic content of that word, concept or other        things can be determined by a machine system    -   providing a structured representation of data that represents a        natural language conclusion, inference or other logical process;    -   generating a structured representation of the clues in a        crossword puzzle and the crossword grid;    -   a machine system autonomously using the structured        representations of natural language words, concepts, or other        things and the natural language conclusions, inferences or other        logical processed to generate candidate answers to the clues.

The following sub-features may apply to any of the above Concepts A—D.

-   -   the heterogeneous data is sufficiently broad to render a schema        impractical.    -   the heterogeneous data is not stored as a schema.    -   the heterogeneous data is not stored as natural language.    -   the universal corpus representing the meaning of natural        language words includes all words in a dictionary.    -   the universal corpus of natural language concepts is derived        from a machine analysis of natural language documents or        conversations.    -   the universal corpus of natural language words, concepts or        other things is derived from a machine analysis of natural        language documents or conversations.    -   the structured representation of a word encodes the semantic        meaning of that word through links to structured representations        of related words, concepts, other terms, or logical processes.    -   the structured representation of a specific word, concept, or        other thing is, once generated, a unique identifier for that        specific word, concept, or other thing in the universal language        or corpus.    -   there are multiple different structured representations of the        same specific word, concept, or other thing, but each exists        only locally and is not part of the universal language or        corpus.    -   the unique identifier is a 128 bit UUID.    -   the structured representation of a specific word, concept, or        other thing can relate to any of: every specific human being,        the concept of human being (of which any specific human being is        a member), every file, every web page, every audio recording or        video, specific relationships (including the relationship that        links any specific human being to the concept of human being),        attributes, specific types of language nuance and every row and        item in a relational database table.    -   the structured representation is a semantic node in an ordered        or partially ordered combination or network of combined or        linked nodes, the combined or linked nodes being the structured        representation of the related words, concepts, other terms, or        logical processes.    -   combining nodes generates a new word, concept, or other term        with a new meaning or semantic content in the universal        language.    -   an ordered or partially ordered collection of structured        representations captures a specific meaning or semantic content.    -   a machine learning system generates new nodes and links between        nodes by autonomously learning from natural language documents        or conversations.    -   a structured representation represents a natural language        conclusion, inference or other logical process.    -   structured representations of conclusions, inferences or other        logical processes are used for reasoning and outputting the        results of that reasoning.    -   the nodes of structured representations are used to constitute a        memory or repository of knowledge or relationships between about        words, concepts, other things, and conclusions, inferences or        other logical processes.    -   the nodes of structured representations are used to understand        spoken or written communication.    -   the node networks of structured representations are used to        generate spoken or written communication.    -   the node networks of structured representations constitute a        basis for a general intelligence system.    -   the representation of heterogeneous data is used in an        application relating to managing health.    -   the representation of heterogeneous data is used in an        application relating to managing nutrition.    -   the representation of heterogeneous data is used in an        application relating to managing matching job seekers to jobs.    -   the representation heterogeneous data is used in an application        relating to accounting.    -   the representation of heterogeneous data is used in an        application relating to a voice assistant or chatbot.    -   the heterogeneous data is used in an application relating to        searching the WWW.

Further aspects of an example of the present invention are described bythe following clauses

UL or Similar Powered System for Vertical Applications

(1) A system operable to provide a useful vertical application where theuseful vertical application requires data which is heterogeneous andextremely broad in scope, comprising at least one data store containinga machine-readable representation of the data that encodes meaning.

(2) The system described in clause 1 where the useful verticalapplication is an application operable to automatically match candidatesto jobs or a health application or an accountancy application or achatbot or a voice assistant.

(3) The system of clause 1 or clause 2 where the machine-readablerepresentation of the data is a machine language comprising combinationsof semantic nodes that represent entities and where meaning comes fromthe choice of semantic nodes and the way they are combined.

(4) The system of clause 3 where the system is further operable toreceive a description of an entity from a remote system and use thedescription to return a semantic node corresponding to the entity.

(5) the system of any previous clause where the data includes arepresentation of computational capabilities that are available to theapplication.

(6) the system of any previous clause where the system is furtheroperable to achieve automatic identification of data for removal fromthe data store.

(7) the system of any previous clause where the system is furtheroperable to reason with reference to the contents of the at least onedata store wherein new useful data is generated of use to the usefulvertical application.

(8) the system of clause 7 where the new useful data is stored enablingthe new useful data to be used in the future without further reasoning.

(9) the system of clause 6 where the automatic identification of datafor removal from the data store is achieved using analysis of signalsconcerning the veracity or utility of the data from the applicationusers.

Intelligent System Driven by Tenets

(1) a system comprising at least one data store containingmachine-readable tenets which represent goals and rules to guide thesystem and where the system is further operable to do actions thatconform with the tenets by referencing the tenets.

(2) The system of clause 1 where the system is further operable to checkpotential actions against the tenets and determine the potentialactions' conformity with the tenets.

(3) The system of clause 1 or 2 where the system is further operable topropose actions that conform to the tenets by referencing the tenets.

(4) The system of any previous clause where the actions includecommunicating with users in written form.

(5) the system of any previous clause where the actions includecommunicating with users in spoken form.

(6) the system of any previous clause where the tenets include at leastone measure the system should try to maximize.

(7) the system of clause 6 where the at least one measure includes userhappiness.

(8) the system of any previous clause where the tenets include at leastone measure the system should try to minimize.

(9) the system of clause 8 where the at least one measure includes userunhappiness.

(10) the system of any previous clause where the tenets include at leastone rule for actions the system must never do and where the system isfurther operable to avoid doing the actions the system must never do byreferencing the tenets.

(11) the system of any previous clause where the tenets include at leastone suggestion of what action to do in a defined circumstance.

(12) the system of any previous clause where the actions includeaccessing other remote computer systems.

(13) the system of any previous clause where the actions includechanging the state of devices linked to the system via a network.

(14) the system of any previous clause where the actions includeinitiating a spoken interaction with a human being.

(15) the system of any previous clause where the system furthercomprises at least one data store containing a machine-readablerepresentation of the world that encodes meaning and where the system isfurther operable to reason with reference to the machine-readablerepresentation of the world to select actions that conform with thetenets.

(16) the system of clause 15 where the machine-readable representationof the world comprises a representation of valid reasoning steps andwhere the system is further operable to utilise the representation ofvalid reasoning steps to reason.

(17) the system of clause 15 or clause 16 where the machine-readablerepresentation of the world includes a representation of computationalcapabilities that are available to the system and where the system isfurther operable to utilise the computational capabilities byreferencing the machine-readable representation.

(18) The system of clause 15, 16 or 17 where the system is operable tolearn and augment the machine-readable representation of the world.

(19) The system of clause 18 where the system is operable to learn fromcommunication with at least one user.

(20) The system of clause 18 where the system is operable to learn fromat least one external sensor connected to the system via a network.

(21) the system of any previous clause where the machine-readable tenetsare at least partially represented by combinations of identifiers andwhere at least some of the identifiers represent concepts correspondingto real-world things.

(22) The system of clause 21 where the system is further operable toreceive a description of a concept from a remote system and use thedescription to return an identifier which is likely to mean the concept.

(23) the system of any previous clause where the system is operable tocontinuously reason in a way that results in actions that conform withthe tenets.

(24) the system of any previous clause where the system is operable toanswer questions about the tenets from human users.

Intelligent System Driven by Tenets #2

(1) A computer system comprising a long-term memory; a short-termmemory; a tenet-store containing machine-readable tenets representingrules to guide the system and where the computer system is operable toreceive events and utilise the events, the contents of the long-termmemory, the contents of the short-term memory and the tenets to doactions that conform with the tenets.

(2) The computer system of clause 1 where the events includecommunication from at least one user and where the actions includecommunication to at least one user.

(3) the computer system of any previous clause where the system isfurther operable to learn, and store what it has learned to thelong-term memory.

(4) the computer system of any previous clause where the computer systemis not operable to change the tenets.

(Extra Safe Examples:)

(5) the computer system of clause 4 where the tenets include a tenetprohibiting actions which might result in changes to the tenets.

(6) the computer system of any previous clause where the system isfurther operable to do an independent check of each potential actionagainst the tenets and will discard the potential action if theindependent check finds that it is incompatible with the tenets.

(7) the computer system of any previous clause which is further operableto actively exclude knowledge on itself from being used in determiningactions.

Translation

(1) A method of generating a machine-readable semantic representation ofa section of natural language comprising passing the passage of naturallanguage through a sequence-to-sequence neural architecture trained ontraining data comprising pairs of natural language and a correspondingstructured representation that encodes meaning.

(2) The method of clause 1 where the neural architecture comprises anencoder and decoder and where the method comprises the further step ofusing beam searching during decoding of the semantic representationsfrom the decoder to remove invalid semantic representations.

(3) The methods of clause 1 or 2 where the section of natural languageis a question and where the method further comprises the step ofanswering the question with reference to the semantic representation.

(4) The methods of clause 1 or 2 where the section of natural languageis one or more documents and where the method further comprises thesteps of utilising the semantic representation of the one or moredocuments to answer questions.

(5) The methods of clause 3 or 4 where the method further comprises thestep of reasoning with reference to the semantic representation toproduce further representations not present prior to this step.

Job Matching Application

(1) A system operable to match candidates to open jobs comprising atleast one data store containing:

a plurality of candidate résumés where at least some parts of at leastsome of the candidate résumés are in a structured machine-readable formthat encodes meaning;

a plurality of job specifications for open roles where at least someparts of at least some of the job specifications are stored in thestructured machine-readable form that encodes meaning and

where the system is further operable to match the plurality of candidaterésumés with the plurality of job specifications to identify highconfidence matches between candidates and open roles.

(2) the system of clause 1 where the structured machine-readable form isa language that represents meaning by creating combinations ofidentifiers and where at least some of the identifiers represent humanskills and experience.

(3) the system of any previous clause where the at least one data storefurther stores a representation of candidates' desired roles at leastpartially represented in the structured machine-readable form and wherethe system is further operable to match open roles against therepresentation of candidates' desired roles in order to improve thematches between candidates and open roles.

(4) the system of any previous clause where the system is furtheroperable to send a push notification to a mobile device when a highconfidence match is found.

(5) the system of any previous clause where the system is furtheroperable to explain how the candidate matches the role by generating anexplanation of which bits of the job specification match the skills andexperience of the candidate.

(6) the system of clause 5 where the explanation is in a naturallanguage.

(7) the system of any previous clause where the system is operable tomatch requirements in job specifications to the skills and experience ofa candidate where there are no keywords in common between the relevantparts of the natural language versions of the candidate résumé and jobspecification.

(8) the system of any previous clause where the system is operable tomake a sequence of logical reasoning steps in order to match the skillsor experience of a candidate with a requirement in a job specification.

Health Application

(1) A system for managing a broad set of health data for one or morepeople where at least some of the health data is represented in astructured machine-readable form that encodes meaning stored within oneor more data stores.

(2) The system of clause 1 where the health data includes nutrition dataabout food or drink that has been consumed by at least one of the one ormore people.

(3) The system of clause 2 where the nutrition data includes data thatrepresents the uncertainty about the volume or composition of what wasconsumed.

(4) The system of any previous clause where the health data comprisesdata about the results of blood tests or measurements or bodycomposition or activity information or genetic data or microbiome dataor bowel motion events or sleep data or workout data or activity data orsymptoms of diseases or human moods or menstruation or ingestion ofmedication or medical conditions or data from any wearable device.

(5) the system of any previous clause where the system is furtheroperable to converse with one or more users via text.

(6) the system of any previous clause where the system is furtheroperable to enable selected other people to converse with the one ormore users and to enable the selected other people to view relevanthealth data.

(7) the system of any previous clause where the system is furtheroperable to create graphs of specific types of health data togetherwherein users can see how different data correlates.

(8) The system of any previous clause where the system is furtheroperable to analyse the health data to uncover insights relevant to thespecific user's health.

(9) The system of the previous clause where the insights includepotential dietary intolerances or behaviours that influence sleep.

(10) The system of any previous clause where elements of the health dataare combined to calculate an additional item of health data not alreadypresent in the health data.

(11) The system of clause 10 where the additional item of health data isan estimate of caffeine present in a user's body at a particular time.

Accounting Application

(1) The system for managing accounting data for at least one businesswhere at least some of the accounting data is represented in astructured machine-readable format that encodes real-world meaningstored within one or more data stores.

(2) The system of clause 1 where the structured machine-readable formatis comprised of combinations of identifiers where at least some of theidentifiers represent real-world entities relevant to the activities ofthe at least one business and where further meaning is encoded from thechoice of combinations of the identifiers.

(3) The system of any previous clause where the system is operable toautomatically present the accountancy data in a plurality of differentaccountancy standards.

(4) The system of any previous clause where the system is operable toanswer questions about the activities of the at least one business.

Privacy-Enhanced Voice Assistant

(1) A system provided by a system provider for providing services to atleast one user via a voice user interface comprising at least one devicelocal to the at least one user where the at least one device is operableto stream sound data to one or more remote data stores where the sounddata is cryptographically stored within the one or more remote datastores using a cryptographic method where at least two of at least twodifferent cryptographic keys are needed to read the sound data.

(2) The system of clause 1, where a first one of the at least twodifferent cryptographic keys is held within the at least one devicelocal to the user and where a second one of the at least two differentcryptographic keys is held by the system provider.

(3) The system of clause 2, where the number of different cryptographickeys is at least three and where a third one of the differentcryptographic keys is held by an entity distinct from both the user andthe system provider.

(4) The system of any previous clause operable to stream general soundfrom the at least one device and to utilise information learned from thegeneral sound to improve its value to the at least one user.

Enhanced Privacy Mode

A system with a voice user interface initiated with a first wakeword,where the system is operable to enter a privacy-preserving staterequiring a second wakeword and where the second wakeword issufficiently long or unusual that a false recognition of the secondwakeword is significantly more improbable relative to the first wakeword

Multiple Voice Assistant System

(1) A system operable to deliver the experience of a plurality ofdifferent voice assistants to a plurality of users comprising at leastone data store containing personality information which determines thepersonality of at least some of the plurality of different voiceassistants.

(2) The system of clause 1, where the personality information includesinformation about the voice assistant's gender or name or voice or moodsor emotional reactions or level of formality or position on theextrovert-introvert scale or position on any Myers Briggs scale or aMyers Briggs categorisation or categorisation in a personality test orvisual appearance.

(3) The system of any previous clause where the at least one data storefurther comprises at least one set of machine-readable tenets whichrepresent goals and rules to guide at least some of the plurality ofvoice assistants and where the system is further operable to do actionsthat conform with the tenets by referencing the tenets.

(4) The system of clause 3 where the at least one set ofmachine-readable tenets is a plurality of sets of machine-readabletenets and where selected ones of the plurality of different voiceassistants are mapped to selected ones of the plurality of sets ofmachine-readable tenets wherein different voice assistants are driven bydifferent tenets.

(5) The system of any previous clause where the at least one data storefurther comprises private user data accessed only by selected ones ofthe plurality of different voice assistants.

Example Use Cases

In examples, examples of the inventions may be used in the followingapplications:

-   -   any language based man/machine interface spoken or in text form,        where the machine user experience is expressed in UL.    -   converting web pages into UL for search and analysis (e.g. in        the limit, all web pages).    -   converting all maps (especially ultra-high resolution maps        needed for autonomous driving and related metadata) into UL.    -   location based search against mapping data expressed in UL.    -   identifying relevant adverts and news to serve someone based on        their social media profile, expressed in UL.    -   identifying relevant adverts and news to serve someone based on        their web search and web browsing history, expressed in UL.    -   suggesting potential friends or contacts based on similar social        media or work profiles, expressed in UL.    -   Identifying abusive postings, all converted into UL, on social        media.    -   Identifying messages and posts, all converted into UL, with        national security or crime implications.    -   analysing customer reviews and feedback, all converted into UL.    -   analysing shopping requests, all converted into UL, to identify        matching products against a product database expressed in UL.    -   automated answering of questions from analysing web pages, all        converted into UL.    -   dating web sites based on matching profiles, converted into UL,        or identifying other correlations that indicate compatibility.    -   generating summaries, e.g. news summaries, from source documents        converted into UL.

Note

It is to be understood that the above-referenced arrangements are onlyillustrative of the application for the principles of the presentinvention. Numerous modifications and alternative arrangements can bedevised without departing from the spirit and scope of the presentinvention. While the present invention has been shown in the drawingsand fully described above with particularity and detail in connectionwith what is presently deemed to be the most practical and preferredexample(s) of the invention, it will be apparent to those of ordinaryskill in the art that numerous modifications can be made withoutdeparting from the principles and concepts of the invention as set forthherein.

Appendix 1

Key Concepts

This Appendix 1 summarises the key Concepts disclosed in thisspecification. We organise these key Concepts into the following 14categories:

Concepts

A. Brackets to disambiguate combinations of nodes

B. Shared syntax across facts, queries and reasoning

C. Nesting of nodes

D. ID selection

E. Any client can generate a semantic node or passage

F. Consolidated universal language (UL) concepts

G. Question answering

H. Learning

I. Translation to and from UL

J. Semantic node resolution

K. Translation between natural languages

L. Voice Assistant

M. Tenets

N. Use cases:

-   -   N1: Man/machine interface    -   N2: Search and Analysis of Documents or web pages.    -   N3. Mapping data represented as UL, associated systems utilising        mapping data and location based search    -   N4. Identifying relevant adverts and news    -   N5. Aggregation and summarisation of news    -   N6. Matching between people using UL    -   N7. Identifying abusive or untrue postings in social media    -   N8. Analysis of Customer Reviews    -   N9. Shopping queries and product requests    -   N.10 Job matching    -   N.11 Horizontal Health Application    -   N.12 Accounting    -   N.13 Voice Assistants/Chatbots

Note that any Concept A-N can be combined with any one or more otherConcepts A-N and any Concept A-N can be combined with any one or moreoptional features from any one or more other Concepts A-N.

We define each of these Concepts as follows:

Machine-Readable Language: Semantic Nodes and Passages

A. Brackets to Disambiguate Combinations of Nodes

The UL model uses bracketed combinations of nodes as the sole or primarymechanism for representing unambiguous meaning yet still achievesenormous expressivity. This enables faster processing of UL compared toother methods where there is a proliferation of different disambiguationmechanisms. It also simplifies storage enabling faster search andaccess. It also makes it faster to write UL compared to other languagesand hence scales adoption. It also reduces the complexity and thus makesfeasible many of the applications of the technology.

We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:        -   (a) storing in a memory a structured, machine-readable            representation of data that conforms to a machine-readable            language, where the structured, machine-readable            representation includes a single syntactical item to            disambiguate the meaning of structured representations of            data;        -   (b) automatically processing the structured,            machine-readable representation for one or more of the            following: to derive facts or relationships, to reason, to            learn, to translate, to answer questions, to process natural            language content, to enable man-machine interaction, to            represent and to police rules or tenets, to enable one or            more vertical applications.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, where the structured, machine-readable representation        includes a single syntactical item to disambiguate meaning;    -   (b) automatically process the structured, machine-readable        representation for one or more of the following: to derive facts        or relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprising semantic nodes and        passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other Optional Features

-   -   the single syntactical item to disambiguate meaning is        parentheses or brackets.    -   the single syntactical item to disambiguate meaning is the only        syntactical item to disambiguate the meaning of different        combinations of structured, machine-readable representation of        data.    -   the single syntactical item to disambiguate the meaning of        different combinations of structured, machine-readable        representation of data is the primary syntactical item to        disambiguate the meaning of the combination.    -   the single syntactical item to disambiguate meaning represents        nesting of the structured, machine-readable representation of        data.    -   the single syntactical item to disambiguate meaning represents        nesting of semantic nodes and passages.    -   the single syntactical item to disambiguate meaning represents        nesting of semantic nodes and passages to any arbitrary depth.    -   the single syntactical item to disambiguate meaning requires        that semantic nodes and passages can only be combined in nested        combinations.    -   the single syntactical item to disambiguate meaning allows for        expressions to be nested indefinitely to allow a user to define        a concept, coupled with contextual information about the        concept, as a hierarchy of semantic nodes.    -   the single syntactical item to disambiguate meaning allows for a        combination semantic nodes to contain any finite number of        semantic nodes and the semantic nodes within them can also be        combination nodes creating any level of nesting.    -   The syntax of the structured, machine-readable representation of        data conforms or substantially conforms to the production        grammar “<passage>::=<id>|<passage>::=(<passage><passage>*)”        where “<passage>*” means zero or one or more further passages        and where <id> is an identifier for a semantic node.

B. Shared Syntax Across Facts, Queries and Reasoning

The UL model uses a shared syntax that applies to semantic nodes andpassages that represent factual statements, query statements andreasoning statements. This enables faster processing of UL compared toother methods where there is a proliferation of different syntaxes. Italso makes it faster to write UL compared to other languages and hencescales adoption. It also simplifies storage enabling faster search andaccess. It also reduces the complexity and thus increases thefeasibility of many of the applications of the invention.

We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, where the language has a syntax that is a single        shared syntax that applies to passages that represent factual        statements, query statements and reasoning statements;    -   (b) automatically processing the structured, machine-readable        representation for one or more of the following: to derive facts        or relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, where the language has a syntax that is a single        shared syntax that applies to passages that represent factual        statements, query statements and reasoning statements;    -   (b) automatically process the structured, machine-readable        representation for one or more of the following: to derive facts        or relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   the syntax applies to all structured, machine-readable        representations of data.    -   the syntax is a simple unambiguous syntax comprising nesting of        structured, machine-readable representations of data.    -   the syntax is a simple unambiguous syntax comprising nesting of        structured, machine-readable representations of data to any        arbitrary depth.    -   the syntax is a simple unambiguous syntax in which structured,        machine-readable representations of data can only be combined in        nested combinations.    -   the syntax allows for expressions to be nested indefinitely to        allow a user to define a concept, coupled with contextual        information about the concept, as a hierarchy of semantic        structured, machine-readable representations of data.    -   Combinations of structured, machine-readable representations of        data can contain any finite numbers of structured,        machine-readable representations of data creating any level of        nesting.    -   structured, machine-readable representations of data are        semantic nodes or passages.    -   semantic nodes are identified with a UUID.

C. Nesting of Nodes

The UL model uses an unambiguous syntax comprising nesting of semanticnodes and passages, i.e. the structured, machine-readablerepresentations of data. This lack of ambiguity enables machines toprocess and utilise data stored in this model with certainty as to whatis being represented in contrast to the use of a natural language.

We can generalise further to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, where the syntax for the machine-readable language is        a substantially unambiguous syntax comprising nesting of        structured, machine-readable representations of data;    -   (b) automatically processing the structured, machine-readable        representation one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, where the language has a syntax in which the syntax        for the machine-readable language is a substantially unambiguous        syntax comprising nesting of structured, machine-readable        representations of data;    -   (b) automatically process the structured, machine-readable        representation for one or more of the following: to derive facts        or relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   the syntax is a simple unambiguous syntax comprising nesting of        structured, machine-readable representations of data to any        arbitrary depth.    -   the syntax is a simple unambiguous syntax in which structured,        machine-readable representations of data can only be combined in        nested combinations.    -   the syntax allows for expressions to be nested indefinitely to        allow a user to define a concept, coupled with contextual        information about the concept, as a hierarchy of semantic        structured, machine-readable representations of data.    -   Combinations of structured, machine-readable representations of        data can contain any finite numbers of structured,        machine-readable representations of data creating any level of        nesting.    -   structured, machine-readable representations of data are        semantic nodes or passages.    -   semantic nodes are identified with a UUID

D. ID Selection

The UL model uses semantic node identifiers that are selected from anaddress space that is sufficiently large to enable users to select a newidentifier with negligible risk of selecting a previously allocatedidentifier. This enables users to use the present invention with localdata without having to coordinate with any other user, whilst alsobenefitting from shared nodes which have meaning to more than one user.

We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, where the structured, machine-readable representation        of data comprises a plurality of identifiers which are selected        from an address space that is sufficiently large to enable users        to select a new identifier with negligible risk of selecting a        previously allocated identifier;    -   (b) automatically processing the structured, machine-readable        representation one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, where the structured, machine-readable representation        of data comprises a plurality of identifiers which are selected        from an address space that is sufficiently large to enable        client entities to select a new identifier with negligible risk        of selecting a previously allocated identifier;    -   (b) automatically process the structured, machine-readable        representation for one or more of the following: to derive facts        or relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   A semantic node once defined has an identifier or ID.    -   The identifier is selected from an address space that is        sufficiently large to enable client entities to select new        identifiers independently of other client entities without        duplication.    -   The identifier is selected from an address space that is        sufficiently large to enable client entities to select a new        identifier with negligible risk of selecting a previously        allocated identifier.    -   the identifier or ID is a UUID.    -   the ID is a 128-bit version 4 UUID (RFC 4122) with hyphenated        lower-case syntax.    -   the ID is a UUID or a string, such as a Unicode string.    -   a string can denote itself as a structured, machine-readable        representation of data and its meaning is strictly the string        itself only and any natural language meaning contained within        the string is not part of the meaning of the string.    -   a string is represented by an ID as an additional identifier.    -   a string is represented as a UUID or other numerical ID and a        separate passage links the string to that numerical ID to        provide its meaning.    -   two identical strings used as structured, machine-readable        representations of data have universal meaning as that string.    -   any user can coin its own structured, machine-readable        representation of data with its own local meaning by picking an        unused identifier.    -   any user can coin its own identifier for a semantic node even if        another identifier is already used for the semantic node.    -   any user is free to define its own meaning to combinations of        structured, machine-readable representations of data.    -   there can be multiple different structured, machine-readable        representation of data for the same specific word, concept, or        other thing.    -   any user that chooses to create passages that use shared        structured, machine-readable representation of data is also        expressing the same meaning by combining them, so that the        meaning that comes from combining shared structured,        machine-readable representations of data is universal.    -   each sense of each word in a dictionary is represented by a        structured, machine-readable representation of data.    -   a “shared ID” is an ID used by more than one user; a “private        ID” or “local ID” is similarly an ID used by only one user and        is not published or exposed to other users; a “public ID” is an        ID that a user has used in UL that can be seen by every user.    -   a semantic node is a structured, machine-readable representation        of data that, once defined, has an identifier so it can be        referred to within the machine-readable language.    -   a passage is a combination of semantic nodes expressing meaning,        and is the sole nesting construct.    -   semantic nodes in infinite classes can be represented as a        combination of a plurality of other nodes.

E. Any Client can Generate a Semantic Node or Passage

The UL model uses semantic node identifiers that are selected from anaddress space that is sufficiently large to enable users to select a newidentifier with negligible risk of selecting a previously allocatedidentifier. This makes it faster and easier to create UL compared toother languages and hence scales adoption. It also enables users toapply the technology to their local data while still benefitting frompassages and implementations generated by other users.

We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, and in which the machine-readable language is scalable        since there are no restrictions on which users can create a        structured, machine-readable representation of data or related        identifier;    -   (b) automatically processing the structured, machine-readable        representation one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, and in which the machine-readable language is scalable        since there are no restrictions on which users can create a        structured, machine-readable representation of data or related        identifier;    -   (b) automatically process the structured, machine-readable        representation for one or more of the following: to derive facts        or relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   the machine-readable language is a universal language for which        substantially anything expressible in natural language is        expressible as a structured, machine-readable representation of        data or a combination of structured, machine-readable        representations of data.    -   a structured, machine-readable representation of data represents        a specific entity, such as a word, concept, or other thing, and        once generated, identifies uniquely that specific word, concept,        or other thing in the universal language.    -   an ordered or partially ordered collection of structured,        machine-readable representations of data captures a specific        meaning or semantic content.    -   the meaning of a structured, machine-readable representation of        data comes from statements written in the machine-readable        language.    -   the meaning of a structured, machine-readable representation of        data comes from other structured, machine-readable        representations of data that represents things that have been        said about the structured, machine-readable representation of        data.    -   a semantic node that represents an entity encodes the semantic        meaning of that entity through links to structured,        machine-readable representations of data of related words,        concepts, other terms, or logical processes.    -   combining structured, machine-readable representations of data        generates a new word, concept, or other term with a new meaning        or semantic content in the machine-readable language.    -   the machine-readable language is understandable to human users        where it corresponds to an equivalent statement in natural        language.    -   the machine-readable language is scalable since any natural        language word, concept, or other thing can be represented by a        structured, machine-readable representation of data.    -   the machine-readable language is scalable since there are no        restrictions on which users can create a structured,        machine-readable representation of data.    -   a semantic node is a structured, machine-readable representation        of data that, once defined, has an identifier so it can be        referred to within the machine-readable language.    -   a passage is a combination of semantic nodes expressing meaning,        and is the sole nesting construct.

F. Consolidated UL Concepts

We can bring the above concepts together as follows:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory structured, machine-readable        representations of data that conform to a machine-readable        language in which one or more of the following apply:        -   a single syntactical item is used to disambiguate the            meaning of structured representations of data;        -   the syntax for the machine-readable language is a single            shared syntax that applies to passages that represent            factual statements, query statements and reasoning            statements;        -   the syntax for the machine-readable language is a            substantially unambiguous syntax comprising nesting of            structured representations of data;        -   a structured representation of data includes an identifier            selected from an address space that is sufficiently large to            enable users to select a new identifier with negligible risk            of selecting a previously allocated identifier;        -   the machine-readable language is scalable since there are no            restrictions on which users can create a structured            representations of data or related identifier;    -   (b) automatically processing the structured representations of        data for one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory or access from a memory a structured,        machine-readable representation of data that conforms to a        machine-readable language comprising semantic nodes and passages        in which one or more of the following apply:        -   a single syntactical item is used to disambiguate the            meaning of structured representations of data;        -   the syntax for the machine-readable language is a single            shared syntax that applies to passages that represent            factual statements, query statements and reasoning            statements;        -   the syntax for the machine-readable language is a            substantially unambiguous syntax comprising nesting of            structured representations of data;        -   a structured representation of data includes an identifier            selected from an address space that is sufficiently large to            enable users to select a new identifier with negligible risk            of selecting a previously allocated identifier;        -   the machine-readable language is scalable since there are no            restrictions on which users can create a structured            representations of data or related identifier;    -   (b) automatically process the structured representations of data        for one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

G. Question Answering

The UL model enables automated answering of questions: a question isrepresented by passages or combinations of semantic nodes and an answercan be automatically generated by three different processes: matchingthe question with passages previously stored in a passage memory store;(ii) fetching and executing one or more computation units, wherecomputation units represent computational capabilities relevant toanswering the question; (iii) fetching and execution of one or morereasoning passages, which represent the semantics of potentiallyapplicable reasoning steps relevant to answering the question. Thisapproach makes highly-scalable, rapid, accurate, semantically basedquestion answering possible. The questions can come from machines; orfrom human users after translating the natural language question into ULand the response back into natural language. We can generalise asfollows:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, and in which a question is represented in the memory        as a structured, machine-readable representation of data; and    -   (b) automatically generating a response to the question, using        one or more of the following steps: (i) matching the question        with structured, machine-readable representations of data        previously stored in a memory store; (ii) fetching and executing        one or more computation units, where computation units represent        computational capabilities relevant to answering the        question; (iii) fetching and execution of one or more reasoning        passages, which are structured, machine-readable representations        of data that represent the semantics of potentially applicable        reasoning steps relevant to answering the question;        -   and in which the representation of the question, the            structured, machine-readable representations of data            previously stored in the memory store, the computation units            and the reasoning passages are all represented in            substantially the same machine-readable language.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language, and in which a question is represented in the memory        as a structured, machine-readable representation of data; and    -   (b) automatically generate a response to the question, using one        or more of the following steps: (i) matching the question with        structured, machine-readable representations of data previously        stored in a memory store; (ii) fetching and executing one or        more computation units, where computation units represent        computational capabilities relevant to answering the        question; (iii) fetching and execution of one or more reasoning        passages, which are structured, machine-readable representations        of data that represent the semantics of potentially applicable        reasoning steps relevant to answering the question        -   and in which the representation of the question, the            structured, machine-readable representations of data            previously stored in the memory store, the computation units            and the reasoning passages are all represented in            substantially the same machine-readable language.    -   In the preferred implementation, the structured,        machine-readable representation of data conforms to a        machine-readable language that comprises semantic nodes and        passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   Reasoning        -   reasoning is done with a series of one or more queries being            answered to see if the reasoning step is valid.        -   reasoning is done with a series of one or more queries being            answered to generate results needed for the result of the            reasoning.        -   passages represent details for the computation unit that are            needed to select and run the computation unit, namely            defining what it can do, how to run it and how to interpret            the results.        -   The step of fetching and execution of one or more initial            reasoning passages returns other passages with unknowns that            need to be processed, and the results of that processing is            a tree of connection that is used to give results for the            initial passage.        -   The tree of connection is stored and the processing of these            other passages with unknowns happens in parallel, allowing            data fetching and exploration of reasoning to be            parallelized.        -   once all passages are processed up to a given maximum            reasoning depth, a second non-parallelised step is used to            walk through this tree of processed passages and unknowns            mappings to find valid answers.        -   each passage in a list of passages is processed to identify            valid mappings from the passage memory store and the            computation units, where a valid mapping for that list of            passages is one where all unknowns have a value and there            are no contradicting mappings between passages in the list.        -   The step of identifying valid mappings recursively looks            through the data and finds all valid mappings for the            initial question which can be returned as the answer.        -   at least some of the passages that have been generated from            reasoning or computation are stored in the passage memory            store, making these available in the future for faster            processing.        -   The history of these generated passages is also stored so            that changes to a trust level in the passages that were used            to generate them can be extended to the trust given to these            generated passages.        -   The history of these generated passages is also stored to            enable the removal of generated passages when the trusted            status of one or more of the passages used to generate them            changes.        -   When a new passage is added to the passage memory store it            is assigned a low initial trust value when added by a normal            user and a higher starting value when added by a privileged            user.        -   Questions are represented in the machine-readable language            with a passage which comprises a node identifying the            passage as a question, language representing zero or one or            more unknown entities being requested within the semantics            of the question and language representing the semantics of            the question and referencing the zero or one or more unknown            entities.        -   Questions are represented in the machine-readable language            with a passage of the form ((Question            <unknowns>)(<passage>)) where Question is a semantic node            and <unknowns> is a list of zero or one or more semantic            nodes representing unknown values (similar in meaning to            letters of the alphabet in algebra) and where <passage> is            where the unknowns are used to express what is being asked.        -   a signal from an application of the system or method is            stored in association with the passages utilised by the            application in order to keep track of the value of the            passages        -   passages are assigned a vector of values where the number at            each index represents a different quality of the passage.        -   the different qualities include veracity, usefulness, and            efficiency.        -   a process that uses the passages utilises a priorities            vector with numbers at each index that indicate how much            they prioritise that value.        -   the overall value of the passage to that process can then be            obtained from the dot product of the vectors.        -   a reasoning engine experiments with high and lower value            passages to answer the question and the answers provided by            the reasoning engine are then monitored for any signals that            would indicate whether the lower value passages have a            positive or negative effect on the answers and this            information then feeds back into an auto-curation process            which re-evaluates the value of the passage with the new            signal.        -   an auto-curation process automatically tests passages to            determine if they should be used for question-answering.        -   the structured, machine-readable representations of data            previously stored in a memory store have been curated with            an automatic method.        -   the question is the result of translating natural language            asked by a user into a substantially semantically-equivalent            representation in the machine-readable language.        -   the response to the question is subsequently translated into            semantically equivalent natural language and presented to            one or more users.        -   the question is the result of translating a question spoken            by a user in a natural language into a substantially            semantically-equivalent representation in the            machine-readable language and the user is subsequently            played a spoken answer where the spoken answer is the result            of translating the response to the question into the natural            language.

H. Learning

-   -   The UL model enables automated learning. Things which are        learned can be stored in UL and are then available for        reasoning, question answering and the other uses and        applications of UL described herein. The results of this        learning contrast with statistical machine-learning where (say)        billions of weights in a very large neural net are adjusted, as        what has been learned is understood, can be explained to human        users and can be reasoned with. We can generalise as follows:    -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) learning new information and representing the new        information in a structured, machine-readable representation of        data that conforms to a machine-readable language;    -   (b) storing the structured machine-readable representation of        data in a memory and automatically processing the structured        representations of data for one or more of the following: to        derive facts or relationships, to reason, to learn, to        translate, to answer questions, to process natural language        content, to enable man-machine interaction, to represent and to        police rules or tenets, to enable one or more vertical        applications.    -   Computer-based system configured to analyse data, the system        being configured to:    -   a) learn new information and representing the new information in        a structured, machine-readable representation of data that        conforms to a machine-readable language;    -   (b) store the structured machine-readable representation of data        in a memory and automatically processing the structured        representations of data for one or more of the following: to        derive facts or relationships, to reason, to learn, to        translate, to answer questions, to process natural language        content, to enable man-machine interaction, to represent and to        police rules or tenets, to enable one or more vertical        applications.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   Learning the new information is obtained from automatically        processing the structured, machine-readable representation of        data to obtain, or learn, new information, and the new        information is itself represented as structured,        machine-readable representations of data that are stored in        memory.    -   Learning new information is obtained from a machine-learning        system which generates classifications or predictions or other        outputs which are represented in the structured,        machine-readable representation of data    -   a machine-learning system processes the semantic nodes and        passages to obtain, or learn, new information.    -   new information is generated by automatically processing the        semantic nodes and passages to answer a question.    -   a question is represented as one or more passages and a response        to the question is automatically generated using one or more of        the following steps: (i) matching the question with passages        previously stored in a passage memory store; (ii) fetching and        executing one or more computation units, where computation units        represent computational capabilities relevant to answering the        question; (iii) fetching and execution of one or more reasoning        passages, which are passages that represent the semantics of        potentially applicable reasoning steps relevant to answering the        question.    -   the new information represented as semantic nodes or passages        are stored and used to improve performance of learning new        facts.    -   the new information represented as semantic nodes or passages        are stored and used to improve reasoning steps.    -   the new information represented as semantic nodes or passages        are stored and used to explain or describe the new information        in natural language.    -   the new information represented as semantic nodes or passages        are stored and used in text or spoken conversations with human        users.    -   learning new information takes place from conversation with or        other natural language provided by human users, in which natural        language provided by users in spoken or written form is        translated into semantic nodes and passages and then new        information represented by these semantic nodes and passages is        stored and used.    -   learning takes place from reasoning, in which semantic nodes and        passages that are generated from a chain of reasoning steps, are        stored and utilised.    -   learning takes place from natural language, in which by        translating all or parts of document sources of natural        language, such as web pages, scientific papers or other articles        into semantic nodes or passages, the resulting semantic nodes or        passages are then utilised by applications.    -   non-document sources of natural language, including audio        recordings or videos containing human speech, are used and        speech recognition technology is first utilised to create a text        transcription of the recordings of voice which are then        translated into semantic nodes and passages.    -   a machine learning system is used to analyse document and        non-document data and create passages from that data.    -   a neural net is trained end-to-end to turn audio or video data        directly into semantic nodes and passages.    -   natural language-based learning is combined with statistical        machine-learning to optimise the translation of document and        non-document data into semantic nodes and passages.    -   a machine learning system is used to generate the semantic nodes        or passages.    -   the machine learning system is a neural network system, such as        a deep learning system.    -   the machine learning system has been trained on training data        comprising natural language and a corresponding structured        machine-readable representation, such as a machine-readable        language comprising semantic nodes and passages    -   a passage of natural language is passed through a        sequence-to-sequence neural architecture trained on training        data comprising natural language and a corresponding structured        representation that encodes meaning.    -   the neural network system is a switch transformer feed forward        neural network system.    -   the neural architecture comprises an encoder and decoder and        beam searching is used during decoding of the semantic        representations from the decoder to remove invalid semantic        representations.    -   structured data, such as the content of a table found in a        document or on the web, a spreadsheet or the content of a        relational, graph or other database is turned into semantic        nodes and passages by assigning semantic nodes to the        identifiers in the structured data and writing semantic nodes        and passages that correspond to the meaning of the structured        data.    -   learning takes place from analysis of other data, in which the        data is processed with an algorithm and the results of that        processing is represented in semantic nodes and passages.

I. Translation to and from UL

Natural language input is translated into UL: this enables the UL systemto understand that natural language input: once translated into UL themeaning in the original natural language is available to the machine.When big deep-learning systems translate between natural languages thereis a belief in the ML community that the representation in the neuralnet after the original sentence is “encoded” corresponds to the meaningof the language in some way as evidenced by the convincing translationproduced in the target language. However that internal encoding isincomprehensible (it is a very big tensor or tensors of weights) andcannot be used for anything other than generating the translation (whichis natural language again so not that useful to a machine). Accessingthe true meaning of documents is one of the big unsolved frontiers ofAI. Translation to and from UL also enables spoken or writtenman-machine interaction with examples of the present invention.

More generally:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in memory a structured machine-readable        representation of data that conforms to a machine-readable        language;    -   (b) receiving a word or sequence of words in a natural language;    -   (c) automatically translating that word or sequence of words        into the machine-readable language by identifying or generating        structured machine-readable representations that semantically        represent the meaning of the word or sequence of words.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in memory a structured machine-readable representation        of data that conforms to a machine-readable language;    -   (b) receive a word or sequence of words in a natural language;    -   (c) automatically translate that word or sequence of words into        the machine-readable language by identifying or generating        structured machine-readable representations that semantically        represent the meaning of the represent that word or sequence of        words.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   a machine learning system is used to generate the semantic nodes        or passages that represent the words or sequence of words in a        natural language.    -   the machine learning system is a neural network system, such as        a deep learning system.    -   a neural architecture is used to generate the machine-readable        language.    -   the neural architecture utilises recurrent neural networks or        LSTMs or attention mechanisms or transformers.    -   the machine learning system has been trained on training data        comprising natural language and a corresponding structured        machine-readable representation, such as a machine-readable        language comprising semantic nodes and passages.    -   a passage of natural language is passed through a        sequence-to-sequence neural architecture trained on training        data comprising natural language and a corresponding structured        representation that encodes meaning.    -   the neural network system is a switch transformer feed forward        neural network system.    -   the neural architecture comprises an encoder and decoder and        beam searching is used during decoding of the semantic        representations from the decoder to remove invalid semantic        representations.    -   the word or sequence of words in a natural language is a        question and the question is answered with reference to the        semantic representation.    -   the word or sequence of words in a natural language is one or        more documents and the semantic representation of the one or        more documents is used to answer question.    -   reasoning with reference to the semantic representation produces        further, new representations.    -   when automatically translating a sequence of words expressed in        the natural language into the machine-readable language, the        structure of the sequence of words is compared with known        machine-readable language structures in the memory to identify        similarities.    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by referencing a store of        previously identified correct translations between the natural        language and the machine-readable language.    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by utilising a pipeline of        functions which transform the word or sequence of words into a        series of intermediate forms.    -   the semantic impact of changes to the word or sequence of words        in a natural language is automatically assessed to determine        whether known or ground truth examples of semantic nodes or        passages can be used that are sufficient accurate.    -   the semantic nodes or passages that represent the words or        sequence of words provides a machine-readable representation of        the meaning of the words or sequence of words.    -   the semantic nodes or passages that represent the words or        sequence of words are processed by a computer-based system for        one or more of the following: to derive facts or relationships,        to reason, to learn, to translate, to answer questions, to        process natural language content, to enable man-machine        interaction, to represent and to police rules or tenets, to        enable one or more vertical applications.    -   the semantic nodes or passages that represent the words or        sequence of words are processed by a computer-based system to        generate an output that is human-readable.    -   the human readable output include one or more of the following:        an answer to a question expressed in the natural language; a        reasoning statement that explains how the system has reached a        conclusion; a learning statement that explains what the system        has learnt; a response in a man/machine interaction.    -   The system is further operable to automatically translate from        the structured-machine readable representation to the natural        language.    -   When translating from the structured-machine readable        representation to the natural language the system varies the        generated translations between alternatives that are        substantially semantically equivalent to create varied and fresh        responses for the benefit of human users.    -   Automatically translating the word or sequence of words into the        machine-readable language is achieved by referencing a context        of information relevant to generating a correct translation.

J. Semantic Node Resolution

The UL model makes it fast and efficient to create consistent semanticnodes and passages: when a user wishes to use a shared, publicidentifier for an entity, it sends a description of that entity to aservice, which then returns the appropriate shared, public identifier ifit exists and can be identified—if not the user can use a newidentifier. This enables users to translate existing data into UL veryeasily while taking advantage of shared information and then use thatrepresentation for the purposes and applications described herein.

More generally:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language;    -   (b) providing a service operable to receive a description of an        entity and return one or more identifiers for structured,        machine-readable representations of data corresponding to the        entity, so that a user is able to use a shared identifier for        the entity.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language;    -   (b) provide a service operable to receive a description of an        entity and return one or more identifiers for structured,        machine-readable representations of data corresponding to the        entity, so that a user is able to use a shared identifier for        the entity.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   the description is partially or fully described in the        machine-readable language.    -   the description is partially or fully written in one or more        natural languages.    -   the service compares the description of the proposed semantic        node or passages with available information about existing        entities to determine if there is a match.    -   the service probabilistically determines if there is a match.    -   the service additionally returns probabilities of matches along        with the one or more identifiers.    -   the service returns a new identifier if no match is found.

K. Translating Between Different Natural Languages

-   -   As the UL representation is intended to fully represent the        meaning of natural language it was translated from, even        potentially representing nuance or properties like level of        formality, it is an advantage to use UL as a kind of        natural-language-independent semantic intermediate language        before translating from it into the target language. This        enables accurate, semantically based translation and greatly        reduces the number of translation systems or models needed to        translate between a large number of pairs of natural languages        as only one translation system or model is needed per natural        language.

More generally:

-   -   A computer implemented method for translating between languages,        comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language;    -   (b) receiving a word or sequence of words in the first natural        language to be translated into the second natural language;    -   (c) automatically translating that word or sequence of words        expressed in the first natural language into the second natural        language by (i) identifying a structured, machine-readable        representation of data that represents the semantics of the word        or sequence of words in the first natural language and (ii)        retrieving a word or sequence of words in the second natural        language that corresponds in meaning to the identified        structured, machine-readable representation of data.    -   Computer-based system configured to translate between languages,        the system being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language;    -   (b) receive a word or sequence of words in the first natural        language to be translated into the second natural language;    -   (c) automatically translate that word or sequence of words        expressed in the first natural language into the second natural        language by (i) identifying a structured, machine-readable        representations of data that represents the semantics of the        word or sequence of words in the first natural language and (ii)        retrieve a word or sequence of words in the second language that        corresponds in meaning to the identified structured,        machine-readable representation of data.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.    -   Other optional features:        -   a machine learning system is used to generate semantic nodes            or passages corresponding to or from words or sequence of            words in a natural language.        -   the machine learning system is a neural network system, such            as a deep learning system.        -   the machine learning system has been trained on training            data comprising natural language and a corresponding            structured machine-readable representation, such as a            machine-readable language comprising semantic nodes and            passages.        -   a passage of natural language is passed through a            sequence-to-sequence neural architecture trained on training            data comprising natural language and a corresponding            structured representation that encodes meaning.        -   the neural network system utilises recurrent neural networks            or LSTMs or attention mechanisms or transformers.        -   the neural network system is a switch transformer feed            forward neural network system.        -   the neural architecture comprises an encoder and decoder and            beam searching is used during decoding of the semantic            representations from the decoder to remove invalid semantic            representations.        -   the semantic impact of changes to the word or sequence of            words in the first natural is automatically assessed to            determine whether known or ground truth examples of semantic            nodes or passages can be used that are sufficient accurate.        -   the word or sequence of words in the second language that            correspond to the identified semantic nodes or passages are            automatically varied to provide for varied translations.

L. Voice Assistant

-   -   UL enables an always-on voice assistant that is able to discern        meaning from inputs (e.g. spoken commands or questions) and        generate semantically meaningful responses, without the need for        a ‘wake word’.    -   We can generalise to:    -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language;    -   (b) automatically and autonomously processing detected audio or        text into the structured representation of data for one or more        of the following: to derive facts or relationships, to reason,        to learn, to translate, to answer questions, to process natural        language content, to enable man-machine interaction, to        represent and to police rules or tenets, to enable one or more        vertical applications.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language;    -   (b) automatically and autonomously process detected audio or        text into the structured representation of data for one or more        of the following: to derive facts or relationships, to reason,        to learn, to translate, to answer questions, to process natural        language content, to enable man-machine interaction, to        represent and to police rules or tenets, to enable one or more        vertical applications.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   autonomous processing of audio or text takes place whenever        audio or text is detected or received.    -   system is continuously receptive to input audio or text.    -   system does not have a wakeword or can operate in a mode where        there is no wakeword.    -   autonomous processing of detected audio or text takes place        without any external trigger event to initiate processing, such        as a wake word, or user instruction or action to initiate        processing.    -   detected audio or text is a question from a user and the        question is automatically processed and an answer automatically        generated and provided to the user.    -   detected audio or text is a statement from a user and the        statement is automatically processed and a response, such as a        conversational response, automatically generated and provided to        the user.    -   detected audio or text is a request from a user for an action to        take place, and the request is automatically processed and the        action executed.    -   detected audio or text is a request from a user for an action to        take place, and the request is automatically processed and the        action executed if doing so optimizes or otherwise positively        affects the achievement or realization of tenets, statements or        other rules.    -   Detected audio or text is cryptographically isolated from the        provider of the system whereby private information cannot be        accessed by the provider of the system.    -   detected audio or text is cryptographically stored using a        cryptographic method where at least two of at least two        different cryptographic keys are needed to read the detected        audio or text.    -   detected audio or text comes from a device local to a user and a        first one of the at least two different cryptographic keys is        associated with the device local to the user and where a second        one of the at least two different cryptographic keys is held by        the system provider.    -   the number of different cryptographic keys is at least three and        a third one of the different cryptographic keys is held by an        entity distinct from both the user and the system provider    -   Multiple voice assistants are provided, such as a unique one per        family.    -   the system is operable to deliver the experience of a plurality        of different voice assistants to a plurality of users comprising        at least one data store containing personality information which        determines the personality of at least some of the plurality of        different voice assistants.    -   the personality information includes information about the voice        assistant's gender or name or voice or moods or emotional        reactions or level of formality or position on the        extrovert-introvert scale or position on any Myers Briggs scale        or a Myers Briggs categorisation or categorisation in a        personality test or visual appearance.

M. Tenets

-   -   UL enables objectives (e.g. maximise client happiness, do not        break the law) to be captured in machine-understandable form:        these are ‘tenets’ and they enable the system to determine        actions and to determine whether or not to execute a candidate        action by determining if doing so would optimise the tenet, or        violate the tenet. It provides the machine with the ability to        act in a moral or ethical manner and to determine its own        behaviour rather than having everything it does determined by        pre-written computer code. This enables scaling of the        capabilities of the system as the system learns without the        addition and debugging of new program code. It also enables        consistent changes or variations in the behaviour or product        rules of the system to be made very quickly without any code        being changed.    -   We can generalise to:    -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language;        -   in which the structured representation of data includes one            or more tenets, statements or other rules defining the            objectives or motives, also represented using the structured            representation of data;    -   (b) analysing a potential action to determine whether executing        the action would optimize or otherwise affect achievement or        realization of those tenets, statements or other rules;    -   (c) automatically selecting, deciding on or executing actions        only if they optimize or otherwise positively affect the        achievement or realization of those tenets, statements or other        rules.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language;        -   in which the structured representation of data includes one            or more tenets, statements or other rules defining the            objectives or motives, also represented using the structured            representation of data;    -   (b) analyse a potential action to determine whether executing        the action would optimize or otherwise affect achievement or        realization of those tenets, statements or other rules;    -   (c) automatically select, decide on or execute actions only if        they optimize or otherwise positively affect the achievement or        realization of those tenets, statements or other rules.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.    -   Other optional features:        -   actions that conform to the tenets, statements or other            rules (‘tenets’) are automatically proposed by referencing            the tenets.        -   the actions include communicating with users in written            form.        -   actions include communicating with users in spoken form.        -   the tenets include at least one measure the system should            try to maximise, such as user happiness.        -   the tenets include at least one measure the system should            try to minimise, such as user unhappiness.        -   the tenets include at least one rule for actions the system            must never do.        -   the system is further operable to avoid doing the actions            the system must never do by referencing the tenets.        -   the tenets include at least one suggestion of what action to            do in a defined circumstance.        -   the tenets include sub-tenets which are tenets that relate            to other tenets or which are more specific examples of            another tenet.        -   the actions include accessing other remote computer systems.        -   the actions include changing the state of devices linked to            the system via a network.        -   the actions include initiating a spoken interaction with a            human being.        -   a data store contains a machine-readable representation of            the world that encodes meaning and where the system is            further operable to reason with reference to the            machine-readable representation of the world to select            actions that conform with the tenets.        -   the machine-readable representation of the world comprises a            representation of valid reasoning steps and where the system            is further operable to utilise the representation of valid            reasoning steps to reason.        -   the machine-readable representation of the world includes a            representation of computational capabilities that are            available to the system and where the system is further            operable to utilise the computational capabilities by            referencing the machine-readable representation.        -   the system is operable to learn and augment the            machine-readable representation of the world.        -   the system is operable to learn from communication with at            least one user.        -   the system is operable to learn from at least one external            sensor connected to the system via a network.        -   the machine-readable tenets are at least partially            represented by combinations of identifiers and where at            least some of the identifiers represent concepts            corresponding to real-world things.        -   the system is further operable to receive a description of a            concept from a remote system and use the description to            return an identifier which is likely to mean the concept.        -   the system is operable to continuously reason in a way that            results in actions that conform with the tenets.        -   the system is operable to answer questions about the tenets            from human users.        -   the computer system comprises a long-term memory; a            short-term memory; a tenet-store containing machine-readable            tenets representing rules to guide the system and where the            computer system is operable to receive events and utilise            the events, the contents of the long-term memory, the            contents of the short-term memory and the tenets to do            actions that conform with the tenets.        -   the computer system comprises a component which generates            candidate actions; a component that decides whether to            execute the candidate actions with reference to the tenets            and a component which executes actions.        -   answering a question asked by a human user comprises two            actions—generating a response to the question and            communicating that response to the human user.        -   the events include communication from at least one user and            where the actions include communication to at least one            user.        -   the system is further operable to learn, and store what is            has learned to the long-term memory.        -   the computer system is not operable to change the tenets.        -   the tenets include a tenet prohibiting actions which might            result in changes to the tenets.        -   the system is further operable to do an independent check of            each potential action against the tenets and will discard            the potential action if the independent check finds that it            is incompatible with the tenets.        -   the computer system is further operable to actively exclude            knowledge on itself from being used in determining actions.

Contemplation engine

-   -   potential actions are autonomously generated by the computer        based system.    -   potential actions are autonomously generated by the computer        based system as outputs from processing inputs, such as audio or        text.    -   potential actions are autonomously generated with a process that        operates substantially continuously.    -   potential actions are autonomously generated without any        external trigger event to initiate processing or user        instruction or action to initiate processing.    -   the potential actions are automatically executed if they        optimize or otherwise positively affect the achievement or        realization of those tenets, statements or other rules.

Use Cases

N1: Man/Machine Interface

UL can be used as part of a human/machine interface, where the machineis able to interpret semantically inputs that are spoken, written or GUIinstruction provided by a human and hence enable an improved userexperience.

We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured representation of data including a        representation of a spoken, written or GUI instruction provided        by a human to a human/machine interface;    -   (b) automatically processing the structured representation of        data for one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including a representation of a spoken, written or GUI        instruction provided by a human to a human/machine interface;    -   (b) automatically process the structured representation of data        for one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

N2: Search and Analysis of Documents or Web Pages.

It is possible to automatically translate websites and web documents (inthe limit, the entire WWW) into UL and hence give them a deepmachine-understandable semantic meaning; this makes it possible to useweb documents in far more powerful ways including reasoning from andintegrating the meaning of those documents in ways that were previouslynot possible.

We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including a representation of at least parts of documents        stored in a document store;    -   (b) automatically processing the structured representation of        data for one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications that require        a search for, or analysis of, documents.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including a representation of at least parts of documents        stored in a document store;    -   (b) automatically processing the structured representation of        data for one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications that require        a search for, or analysis of, documents.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   the parts of the documents have been automatically translated        into the machine readable language.    -   a machine learning system is used to generate the semantic nodes        or passages that represent the words in the documents.    -   the machine learning system is a neural network system, such as        a deep learning system.    -   a neural architecture is used to generate the machine-readable        language    -   the neural architecture utilises recurrent neural networks or        LSTMs or attention mechanisms or transformers    -   the machine learning system has been trained on training data        comprising natural language and a corresponding structured        machine-readable representation, such as a machine-readable        language comprising semantic nodes and passages.    -   a passage of natural language is passed through a        sequence-to-sequence neural architecture trained on training        data comprising natural language and a corresponding structured        representation that encodes meaning.    -   the neural network system utilises recurrent neural networks or        LSTMs or attention mechanisms or transformers.    -   the neural network system is a switch transformer feed forward        neural network system.    -   the neural architecture comprises an encoder and decoder and        beam searching is used during decoding of the semantic        representations from the decoder to remove invalid semantic        representations.    -   when automatically translating a sequence of words expressed in        the natural language into the machine-readable language, the        structure of the sequence of words is compared with known        machine-readable language structures in the memory to identify        similarities.    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by referencing a store of        previously identified correct translations between the natural        language and the machine-readable language    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by utilising a pipeline of        functions which transform the word or sequence of words into a        series of intermediate forms    -   user's queries have been automatically translated into UL and        the system responds to the users requests by utilising the        translated UL.    -   method is a web search system and the document store includes        pages from the world wide web which are indexed and then at        least partially translated into UL.    -   translation includes turning natural language components of        these pages into UL or turning tabular or other structured data        into UL.    -   answers to queries include links to web pages containing the        information being searched for or providing the services being        searched for or the system provide the information directly in        the form of a text or spoken answer.    -   direct responses are accompanied by links to the sources of this        information and include associated data such as images or        tables.

N3. Mapping Data Represented as UL, Associated Systems Utilising MappingData and Location Based Search

It is possible to represent mapping and location-based data into UL andhence give them a machine-understandable semantic meaning; this makes itpossible to use mapping and location-based data in far more powerfulways. We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of mapping or location-based        data;    -   (b) automatically processing the structured representation of        data for one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications that use        location-based or mapping data.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of mapping or location-based        data;    -   (b) automatically process the structured representation of data        for one or more of the following: to derive facts or        relationships, to reason, to learn, to translate, to answer        questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications that use        location-based or mapping data.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   mapping data or location-based data has been automatically        translated into the machine readable language.    -   a machine learning system is used to generate the semantic nodes        or passages that represent the mapping data or location-based        data.    -   the machine learning system is a neural network system, such as        a deep learning system.    -   a neural architecture is used to generate the machine-readable        language    -   the neural architecture utilises recurrent neural networks or        LSTMs or attention mechanisms or transformers    -   the machine learning system has been trained on training data        comprising natural language and a corresponding structured        machine-readable representation, such as a machine-readable        language comprising semantic nodes and passages.    -   a passage of natural language is passed through a        sequence-to-sequence neural architecture trained on training        data comprising natural language and a corresponding structured        representation that encodes meaning.    -   the neural network system utilises recurrent neural networks or        LSTMs or attention mechanisms or transformers.    -   the neural network system is a switch transformer feed forward        neural network system.    -   the neural architecture comprises an encoder and decoder and        beam searching is used during decoding of the semantic        representations from the decoder to remove invalid semantic        representations.    -   when automatically translating a sequence of words expressed in        the natural language into the machine-readable language, the        structure of the sequence of words is compared with known        machine-readable language structures in the memory to identify        similarities.    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by referencing a store of        previously identified correct translations between the natural        language and the machine-readable language.    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by utilising a pipeline of        functions which transform the word or sequence of words into a        series of intermediate forms.

N4. Identifying Relevant Adverts and News

UL enables advertisements, news articles or other information items(e.g. on the WWW) to be translated to UL and their semantic meaning madeavailable for machine processing: this enables automated assessment ofrelevance to specific individuals, and hence personalised advertisingetc.

We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language that represents meaning; the structured,        machine-readable representation of data relating to        representations of at least some part of one or more        advertisements, news articles or other information items;    -   (b) automatically processing the structured representation of        data to identify advertisements, news articles or other        information items relevant to a specific individual.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of at least some part of one or        more advertisements, news articles or other information items;    -   (b) automatically process the structured representation of data        to identify advertisements, news articles or other information        items relevant to a specific individual.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   the method determines advertisements, news articles or other        information items relevant to a user by also analysing semantic        nodes that are a representation of user-specific data.    -   the user-specific data includes one or more of the following        relating to a user: social media profile, postings, profile        information, “likes”, web search or web browsing history,        natural language conversation/exchanges between the user and a        system where the system stores and remembers information the        user has given about him or herself    -   advertisements, news articles or other information items        relevant to a specific individual and the user-specific data has        been automatically translated into the machine readable        language.    -   a machine learning system is used to generate the semantic nodes        or passages that represent the advertisements, news articles or        other information items relevant to a specific individual, and        the user-specific data.    -   the machine learning system is a neural network system, such as        a deep learning system.    -   the machine learning system has been trained on training data        comprising natural language and a corresponding structured        machine-readable representation, such as a machine-readable        language comprising semantic nodes and passages.    -   a passage of natural language is passed through a        sequence-to-sequence neural architecture trained on training        data comprising natural language and a corresponding structured        representation that encodes meaning.    -   the neural network system is a switch transformer feed forward        neural network system.    -   the neural architecture comprises an encoder and decoder and        beam searching is used during decoding of the semantic        representations from the decoder to remove invalid semantic        representations.    -   when automatically translating a sequence of words expressed in        the natural language into the machine-readable language, the        structure of the sequence of words is compared with known        machine-readable language structures in the memory to identify        similarities.    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by referencing a store of        previously identified correct translations between the natural        language and the machine-readable language    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by utilising a pipeline of        functions which transform the word or sequence of words into a        series of intermediate forms

N5. Aggregation and summarisation of news

UL enables news from multiple sources (e.g. on the WWW) to be partiallyor fully translated to UL and their semantic meaning made available formachine processing and summarising: this enables automated personalisednews summaries etc. We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of news from multiple sources;    -   (b) automatically processing the structured representation of        data for one or more of the following: to generate a summary of        the news from multiple sources; using the news summaries to        derive facts or relationships, to reason, to learn, to        translate, to answer questions, to process natural language        content, to enable man-machine interaction, to represent and to        police rules or tenets, to enable one or more vertical        applications to use the summaries of news from multiple sources.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of news from multiple sources;    -   (b) automatically process the structured representation of data        for one or more of the following: to generate a summary of the        news from multiple sources; using the news summaries to derive        facts or relationships, to reason, to learn, to translate, to        answer questions, to process natural language content, to enable        man-machine interaction, to represent and to police rules or        tenets, to enable one or more vertical applications to use the        summaries of news from multiple sources.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   news articles relevant to a specific user are determined by also        analysing semantic nodes that are a representation of        user-specific data.    -   the user-specific data includes one or more of the following        relating to a user: social media profile, postings, profile        information, “likes”, web search or web browsing history,        natural language conversation/exchanges between the user and a        system where the system stores and remembers information the        user has given about him or herself    -   news articles have been automatically translated into the        machine readable language.    -   a machine learning system is used to generate the semantic nodes        or passages that represent the news articles.    -   the machine learning system is a neural network system, such as        a deep learning system.    -   a neural architecture is used to generate the machine-readable        language the neural architecture utilises recurrent neural        networks or LSTMs or attention mechanisms or transformers    -   the machine learning system has been trained on training data        comprising natural language and a corresponding structured        machine-readable representation, such as a machine-readable        language comprising semantic nodes and passages.    -   a passage of natural language is passed through a        sequence-to-sequence neural architecture trained on training        data comprising natural language and a corresponding structured        representation that encodes meaning.    -   the neural network system utilises recurrent neural networks or        LSTMs or attention mechanisms or transformers.    -   the neural network system is a switch transformer feed forward        neural network system.    -   the neural architecture comprises an encoder and decoder and        beam searching is used during decoding of the semantic        representations from the decoder to remove invalid semantic        representations.    -   when automatically translating a sequence of words expressed in        the natural language into the machine-readable language, the        structure of the sequence of words is compared with known        machine-readable language structures in the memory to identify        similarities.    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by referencing a store of        previously identified correct translations between the natural        language and the machine-readable language    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by utilising a pipeline of        functions which transform the word or sequence of words into a        series of intermediate forms

N6. Matching between people using UL

UL enables accurate and scalable match-finding: for example, sex, age,and other information relevant to dating or matching for marriage orfriendship or matching for business contacts can be translated to UL andtheir semantic meaning made available for machine processing: thisenables improved automated personalised matching. We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of personal information defining        one or more of the following attributes of a person: sex, age,        information relevant to dating or match-making, information        relevant to identifying business connections; information        relevant to identifying friends;    -   (b) automatically processing the structured representation of        data to provide a compatibility match between persons.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of personal information defining        one or more of the following attributes of a person: sex, age,        information relevant to dating or match-making, information        relevant to identifying business connections; information        relevant to identifying friends;    -   (b) automatically process the structured representation of data        to provide a compatibility match between persons.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   the personal information comprises information coming from        conversations in natural language with the system where the        user's responses are translated into the structured,        machine-readable representation of data.    -   the personal information comprises information coming from the        output of a machine learning model.    -   the personal information comprises information coming from        reasoning.    -   the personal information comprises information come from        learning.

N7. Identifying abusive or untrue postings in social media

UL enables social media postings to be partially or fully translated toUL and their semantic meaning made available for machine processing:this enables automated and high-precision analysis of compliance withrequirements preventing abusive, false or illegal postings. We cangeneralise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of social media postings;    -   (b) automatically processing the structured representation of        data to determine if the postings are compliant with        requirements preventing abusive or illegal postings.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of social media postings;    -   (b) automatically process the structured representation of data        to determine if the postings are compliant with requirements        preventing abusive or illegal postings.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   the processing includes determining whether the social media        postings are factually true.    -   the processing includes determining whether the social media        postings are illegal.    -   the machine-readable representation of data further includes at        least a partial representation of the requirements preventing        abusive or illegal postings and the processing references the        representation of the requirements.    -   the processing additionally generates a natural language        explanation of why the social media posting is not compliant        with the requirements.    -   the processing additionally applies statistical machine-learning        models to the social media postings and uses the results of the        models.

N8. Analysis of Customer Reviews

UL enables customer reviews (e.g. of products, of companies) to betranslated to UL and their semantic meaning made available for machineprocessing: this enables automated analysis of customer reviews. We cangeneralise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of customer reviews of products        or services;    -   (b) automatically processing the structured representation of        data to analyse the customer reviews.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of customer reviews;    -   (b) automatically process the structured representation of data        to analyse the customer reviews.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   the system is further configured to automatically answer        questions about the products or services by referencing the        structured, machine-readable representation of data.    -   the system is further configured to automatically answer general        product questions from customers by referencing the structured,        machine-readable representation.    -   the system is further configured to translate some or all of the        natural language in a customer review into the structured,        machine-readable representation of data.

N9. Shopping queries and product requests

UL enables product descriptions, user product requests, a user'sprevious search, social media or shopping histories to be translated toUL and their semantic meaning made available for machine processing:this enables automated analysis of which products best match a user'sproduct requests or a user's previous search, social media or shoppinghistory. We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of product descriptions, user        product requests, a user's previous search, social media or        shopping histories;    -   (b) automatically processing the structured representation of        data to determine which products best match a user's product        requests or a user's previous search, social media or shopping        history.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of product descriptions, user        product requests, a user's previous search, social media or        shopping histories;    -   (b) automatically process the structured representation of data        to determine which products best match a user's product requests        or a user's previous search, social media or shopping history.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   presenting the products which best match to the user for        possible purchase.    -   automatically processing the structured representation of data        happens as part of a natural language conversation with the user        about what the user is looking to purchase.

N.10 Job matching

UL enables job descriptions and job applicants' skills and experience tobe translated to UL and their semantic meaning made available formachine processing: this enables automated analysis of which jobs bestmatch a job applicant's skills and experience over a very wide varietyof skills, jobs and backgrounds without additional computer code and forthose matches to be very accurate and explainable in natural language.We can generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of job descriptions and job        applicants' skills and experience;    -   (b) automatically processing the structured representation of        data to determine which jobs best match a job applicant's skills        and experience.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of job descriptions and job        applicants' skills and experience;    -   (b) automatically process the structured representation of data        to determine which jobs best match a job applicant's skills and        experience.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   A system is operable to match candidates to open jobs and        comprises at least one data store containing: a plurality of        candidate resumes where at least some parts of at least some of        the candidate resumes are in a structured machine-readable form        that encodes meaning; a plurality of job specifications for open        roles where at least some of parts of at least some of the job        specifications are stored in the structured machine-readable        form that encodes meaning and where the system is further        operable to match the plurality of candidate resumes with the        plurality of job specifications to identify high confidence        matches between candidates and open roles.    -   the structured machine-readable form is a language that        represents meaning by creating combinations of identifiers and        where at least some of the identifiers represent human skills        and experience.    -   at least one data store further stores a representation of        candidates' desired roles at least partially represented in the        structured machine-readable form and where the system is further        operable to match open roles against the representation of        candidates' desired roles in order to improve the matches        between candidates and open roles.    -   the system is further operable to send a push notification to a        mobile device when a high confidence match is found.    -   the system is further operable to explain how the candidate        matches the role by generating an explanation of which bits of        the job specification match the skills and experience of the        candidate.    -   the explanation is in a natural language.    -   the system is operable to match requirements in job        specifications to the skills and experience of a candidate where        there are no keywords in common between the relevant parts of        the natural language versions of the candidate resume and job        specification.    -   the system is operable to make a sequence of logical reasoning        steps in order to match the skills or experience of a candidate        with a requirement in a job specification.

N.11 Horizontal Health Application

UL supports the creation of a horizontal health application able tointegrate an extremely broad amount of heterogeneous health data. We cangeneralise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of personal health or medical        data;    -   (b) automatically processing the structured representation to        analyse the personal health or medical data.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of personal health or medical        data;    -   (b) automatically process the structured representation to        analyse the personal health or medical data.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Optional features:

-   -   a broad set of health data for one or more people is managed and        where at least some of the health data is represented in a        structured machine-readable form that encodes meaning stored        within one or more data stores.    -   the health data includes nutrition data about food or drink that        has been consumed by at least one of the one or more people.    -   the nutrition data includes data that represents the uncertainty        about the volume or nutritional information or composition of        what was consumed.    -   the health data comprises data about the results of blood tests        or measurements or body composition or activity information or        genetic data or microbiome data or bowel motion events or sleep        data or workout data or activity data or symptoms of diseases or        human moods or menstruation or ingestion of medication or        medical conditions or data from any wearable device.    -   conversing with one or more users via text is enabled.    -   selected other people are enabled to converse with the one or        more users and to view relevant health data.    -   graphs of specific types of health data are created whereby        users can see how different data correlates.    -   health data is analysed to uncover insights relevant to the        specific user's health.    -   include potential dietary intolerances or behaviours that        influence sleep.    -   elements of the health data are combined to calculate an        additional item of health data not already present in the health        data.    -   the additional item of health data is an estimate of caffeine        present in a user's body at a particular time.

N.12 Accounting

UL enables financial or accounting information to be translated to ULand their semantic meaning made available for machine processing: thisenables automated analysis of financial or accounting information. Wecan generalise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of financial or accounting        information;    -   (b) automatically processing the structured representations to        analyse the personal financial or accounting information.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of financial or accounting        information;    -   (b) automatically process the structured representations to        analyse the financial or accounting information.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.

Other optional features:

-   -   accounting data for at least one business is processed, and at        least some of the accounting data is represented in a structured        machine-readable format that encodes real-world meaning stored        within one or more data stores.    -   the structured machine-readable format is comprised of        combinations of identifiers where at least some of the        identifiers represent real-world entities relevant to the        activities of the at least one business and where further        meaning is encoded from the choice of combinations of the        identifiers.    -   accountancy data is automatically presented in a plurality of        different accountancy standards.    -   answer to questions about the activities of the at least one        business are generated.

N.13 Voice Assistants/Chatbots

Natural language directed to a voice assistant or chatbot can betranslated into UL and the UL representation used internally to answerquestions, converse or take actions. This horizontal representationenables easier scaling of the voice assistant or chatbot's capabilitiesand makes it easier for the system to work with large numbers of othernatural languages as only the translation steps need to change. We cangeneralise to:

-   -   A computer implemented method for the automated analysis or use        of data, comprising the steps of:    -   (a) storing in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of user speech or text input to a        human/machine interface;    -   (b) automatically processing the structured representations to        analyse the user speech or text input.    -   Computer-based system configured to analyse data, the system        being configured to:    -   (a) store in a memory a structured, machine-readable        representation of data that conforms to a machine-readable        language; the structured, machine-readable representation of        data including representations of user speech or text input to a        human/machine interface;    -   (b) automatically process the structured representations to        analyse the user speech or text input to a human/machine        interface.    -   In the preferred implementation, the structured,        machine-readable representation of data that conforms to a        machine-readable language comprises semantic nodes and passages;        -   and in which a semantic node represents an entity and is            itself represented by an identifier; and a passage is            either (i) a semantic node or (ii) a combination of semantic            nodes; and where machine-readable meaning comes from the            choice of semantic nodes and the way they are combined and            ordered as passages.    -   Other optional features:        -   Privacy preserving mode            -   a first wakeword initiates processing, and a                privacy-preserving state is then entered, requiring a                second wakeword and where the second wakeword is                sufficiently long or unusual that a false recognition of                the second wakeword is significantly more improbable                relative to the first wakeword.    -   Multiple different voice assistants        -   the experience of a plurality of different voice assistants            to a plurality of users is delivered and at least one data            store contains personality information which determines the            personality of at least some of the plurality of different            voice assistants.        -   the personality information includes information about the            voice assistant's gender or name or voice or moods or            emotional reactions or level of formality or position on the            extrovert-introvert scale or position on any Myers Briggs            scale or a Myers Briggs categorisation or categorisation in            a personality test or visual appearance.        -   there is at least one set of machine-readable tenets that            represent goals and rules to guide at least some of the            plurality of voice assistants and actions are then done that            conform with the tenets by referencing the tenets.        -   the at least one set of machine-readable tenets is a            plurality of sets of machine-readable tenets and where            selected ones of the plurality of different voice assistants            are mapped to selected ones of the plurality of sets of            machine-readable tenets whereby different voice assistants            are driven by different tenets.        -   private user data is accessible only by selected ones of the            plurality of different voice assistants.

Device types

-   -   The computer-based system is configured to be a voice assistant.    -   The computer-based system is a voice assistant device configured        to control items in a home, car or other environment, using the        user speech or text input.    -   The computer-based system is a voice assistant device configured        to run on a smartphone, laptop, smart speaker or other        electronic device.    -   The computer-based system is a voice assistant device configured        to run at least in part on cloud or central servers and at least        in part on edge devices.

For each of the Use Case concepts N1-N13, the following apply:

-   -   the method and system uses a single syntactical item, such as        brackets, to disambiguate combinations of nodes, as defined in        Concept A.    -   the method and system uses a shared syntax across factual        statements, queries and reasoning, as defined in Concept B.    -   the method and system uses nesting of nodes, as defined in        Concept C.    -   the method and system uses ID selection, from an address space        that is sufficiently large to enable users to select a new        identifier with negligible risk of selecting a previously        allocated identifier, as defined in Concept D.    -   the method and system imposes no restrictions on which clients        are permitted to generate a semantic node or passage, as defined        in Concept E.    -   the method and system uses the consolidated universal language        concepts, as defined in Concept F.    -   the method and system includes question answering, as defined in        Concept G.    -   the method and system includes learning, as defined in Concept        H.    -   the method and system includes translation, as define in Concept        I.    -   the method and system includes semantic node resolution, as        defined in Concept J.    -   the method and system includes translation between natural        languages, as defined in Concept K.    -   the method and system is used in a voice assistant, as defined        in Concept L.    -   the method and system uses tenets, as defined in Concept M.

Optional Features applicable to all Concepts A-N

Note that in the following, any occurrence of ‘semantic node’ or‘passage’ can be generalised to a ‘structured, machine-readablerepresentation’ and also to a ‘machine representation’. Similarly, anyoccurrence of ‘structured, machine-readable representation’ orequivalent can be generalised to a ‘machine representation’. In theappended Claims, we use the term ‘machine representation’ forconciseness.

Simple Syntax

-   -   the structured, machine-readable representation includes a        single syntactical item to disambiguate the meaning of        structured representations of data.    -   the single syntactical item to disambiguate meaning represents        nesting of the structured, machine-readable representation of        data.    -   the single syntactical item to disambiguate meaning represents        nesting of semantic nodes and passages to any arbitrary depth.    -   the single syntactical item to disambiguate the meaning of the        combination is parentheses or brackets.    -   the single syntactical item to disambiguate the meaning of the        combination is the only syntactical item to disambiguate the        meaning of the combination.    -   the single syntactical item to disambiguate the meaning of the        combination is the primary syntactical item to disambiguate the        meaning of the combination.    -   the syntax applies to all nodes and combinations of nodes.    -   the syntax is a simple unambiguous syntax comprising nesting of        nodes.    -   the syntax is a simple unambiguous syntax comprising nesting of        nodes to any arbitrary depth.    -   the syntax is a simple unambiguous syntax in which semantic        nodes can only be combined in nested combinations.    -   the syntax allows for expressions to be nested indefinitely to        allow a user to define a concept, coupled with contextual        information about the concept, as a hierarchy of semantic nodes.    -   Combination nodes can contain any finite number of semantic        nodes and the semantic nodes within them can also be combination        nodes creating any level of nesting.    -   a semantic link between nodes, such as ISA, is itself a semantic        node.    -   the syntax for the machine-readable language applies to        combinations of semantic nodes that represent factual        statements, query statements and reasoning statements.    -   The syntax of the structured, machine-readable representation of        data conforms or substantially conforms to the production        grammar “<passage>::=<id><passage>::=(<passage><passage>*)”        where “<passage>*” means zero or one or more further passages        and where <id> is an identifier for a semantic node.

Node meaning

-   -   the machine-readable language is a universal language for which        substantially anything expressible in natural language is        expressible as a structured, machine-readable representation of        data or a combination of structured, machine-readable        representations of data.    -   a structured, machine-readable representation of data represents        a specific entity, such as a word, concept, or other thing, and        once generated, identifies uniquely that specific word, concept,        or other thing in the universal language.    -   an ordered or partially ordered collection of structured,        machine-readable representations of data captures a specific        meaning or semantic content.    -   the meaning of a structured, machine-readable representation of        data comes from statements written in the machine-readable        language.    -   the meaning of a structured, machine-readable representation of        data comes from other structured, machine-readable        representations of data that represents things that have been        said about the structured, machine-readable representation of        data.    -   a structured, machine-readable representation of data that        represents an entity encodes the semantic meaning of that entity        through links to structured, machine-readable representations of        data of related words, concepts, other terms, or logical        processes.    -   combining structured, machine-readable representations of data        generates a new word, concept, or other term with a new meaning        or semantic content in the machine-readable language    -   the machine-readable language is understandable to human users        where it corresponds to an equivalent statement in natural        language.

Generating nodes

-   -   A semantic node once defined has an identifier or ID.    -   semantic nodes are identified with a UUID.    -   The identifier is selected from an address space that is        sufficiently large to enable users to select new identifiers        independently of other users without duplication.    -   The identifier is selected from an address space that is        sufficiently large to enable users to select a new identifier        with negligible risk of selecting a previously allocated        identifier.    -   the ID is a UUID.    -   the ID is a 128-bit version 4 UUID (RFC 4122) with hyphenated        lower-case syntax.    -   the ID is a UUID or a string, such as a Unicode string.    -   a string can denote itself as a structured, machine-readable        representation of data and its meaning is strictly the string        itself only and any natural language meaning contained within        the string is not part of the meaning of the string.    -   a string can denote itself as a semantic node and its meaning is        strictly the string itself only and any natural language meaning        contained within the string is not part of the meaning of the        string.    -   a string is represented by an ID as an additional identifier.    -   a string is represented as a UUID or other numerical ID and a        separate passage links the string to that numerical ID to        provide its meaning.    -   two identical strings used as semantic nodes have universal        meaning as that string.    -   any user can coin its own semantic nodes with its own local        meaning by picking an unused identifier.    -   any user can coin its own identifier for a semantic node even if        another identifier is already used for the semantic node.    -   any user is free to define its own meaning to combinations of        semantic nodes.    -   there can be multiple different semantic nodes for the same        specific word, concept, or other thing.    -   any user that chooses to create machine representations, such as        passages, that use shared semantic nodes is also expressing the        same meaning by combining them, so that the meaning that comes        from combining shared semantic nodes is universal.    -   there can be multiple different structured, machine-readable        representation of data for the same specific word, concept, or        other thing.    -   any user that chooses to create passages that use shared        structured, machine-readable representation of data is also        expressing the same meaning by combining them, so that the        meaning that comes from combining shared structured,        machine-readable representations of data is universal.    -   each sense of each word in a dictionary is represented by a        semantic node.    -   a machine learning system generates passages by autonomously        learning from natural language documents or conversations.    -   Passages are derived from a machine analysis of natural language        documents, such as WWW pages or conversations.    -   a semantic node is a structured, machine-readable representation        of data that, once defined, has an identifier so it can be        referred to within the machine-readable language.    -   a “shared ID” is an ID used by more than one user; a “private        ID” or “local ID” is similarly an ID used by only one user and        is not published or exposed to other users; a “public ID” is an        ID that a user has used in UL that can be seen by every user.    -   A passage is a combination of semantic nodes expressing meaning,        and is the sole nesting construct.    -   semantic nodes in infinite classes are represented as a        combination of a plurality of other nodes.

Scalability

-   -   the machine-readable language is scalable since any natural        language word, concept, or other thing can be represented by a        structured, machine-readable representation of data.    -   the machine-readable language is scalable since there are no        restrictions on which users can create a structured,        machine-readable representation of data or related identifier.

Questions

-   -   Questions are represented in the machine-readable language with        a passage which comprises a node identifying the passage as a        question, language representing zero or one or more unknown        entities being requested within the semantics of the question        and language representing the semantics of the question and        referencing the zero or one or more unknown entities.    -   Questions are represented in the machine-readable language with        a passage of the form (Question <unknowns>)(<passage>) where        Question is a semantic node and <unknowns> is a list of zero or        one or more semantic nodes representing unknown values (similar        in meaning to letters of the alphabet in algebra) and where        <passage> is where the unknowns are used to express what is        being asked about.    -   generating responses to queries comprises three operations,        namely matching with structured, machine-readable representation        of data, such as passages, in a store, fetching and execution of        computation units and fetching reasoning passages.    -   a question is represented in the memory as a structured,        machine-readable representation of data, and the representation        of the question, the structured, machine-readable        representations of data previously stored in the memory store,        the computation units and the reasoning passages are all        represented in substantially the same machine-readable language

Reasoning

-   -   Reasoning is where machine-readable language is generated from        other machine-readable language using reasoning steps that are        represented as passages which represent the semantics of the        reasoning steps.    -   reasoning is done with a series of one or more queries being        answered to see if the reasoning step is valid.    -   reasoning is done with a series of one or more queries being        answered to generate results needed for the result of the        reasoning.    -   passages represent details for the computation unit that are        needed to select and run the computation unit, namely defining        what it can do, how to run it and how to interpret the results.    -   The step of fetching and execution of one or more initial        reasoning passages returns other passages with unknowns that        need to be processed, and the results of that processing is a        tree of connection that is used to give results for the initial        passage.    -   The tree of connection is stored and the processing of these        other passages with unknowns happens in parallel, allowing data        fetching and exploration of reasoning to be parallelized.    -   once all passages are processed up to a given maximum reasoning        depth, a second non-parallelised step is used to walk through        this tree of processed passages and unknowns mappings to find        valid answers.    -   each passage in a list of passages is processed to identify        valid mappings from the passage memory store and the computation        units, where a valid mapping for that list of passages is one        where all unknowns have a value and there are no contradicting        mappings between passages in the list.    -   The step of identifying valid mappings recursively looks through        the data and finds all valid mappings for the initial question        which can be returned as the answer.    -   at least some of the passages that have been generated from        reasoning or computation are stored in the passage memory store,        making these available in the future for faster processing.    -   The history of these generated passages is also stored so that        changes to a trust level in the passages that were used to        generate them can be extended to the trust given to these        generated passages.    -   The history of these generated passages is also stored to enable        the removal of generated passages when the trusted status of one        or more of the passages used to generate them changes.    -   When a new passage is added to the passage memory store it is        assigned a low initial trust value when added by a normal user        and a higher starting value when added by a privileged user.    -   a signal from an application of the system or method is stored        in association with the passages utilised by the application in        order to keep track of the value of the passages.    -   passages are assigned a vector of values where the number at        each index represents a different quality of the passage.    -   the different qualities include veracity, usefulness, and        efficiency.    -   a process that uses the passages utilises a priorities vector        with numbers at each index that indicate how much they        prioritise that value.    -   the overall value of the passage to that process can then be        obtained from the dot product of the vectors.    -   a reasoning engine experiments with high and lower value        passages to answer the question and the answers provided by the        reasoning engine are then monitored for any signals that would        indicate whether the lower value passages have a positive or        negative effect on the answers and this information then feeds        back into an auto-curation process which re-evaluates the value        of the passage with the new signal.    -   an auto-curation process automatically tests passages to        determine if they should be used for question-answering.    -   the structured, machine-readable representations of data        previously stored in a memory store have been curated with an        automatic method.    -   the question is the result of translating natural language asked        by a user into a substantially semantically-equivalent        representation in the machine-readable language.    -   the response to the question is subsequently translated into        semantically equivalent natural language and presented to one or        more users.    -   the question is the result of translating a question spoken by a        user in a natural language into a substantially        semantically-equivalent representation in the machine-readable        language and the user is subsequently played a spoken answer        where the spoken answer is the result of translating the        response to the question into the natural language.

Computation units

-   -   a computation unit represents an individual computational        capability that is available for reasoning and other purposes.    -   computation units are semantic nodes.    -   passages, or combinations of semantic nodes, represents details        for the computation unit that are needed to select and run the        computation unit, namely defining what it can do, how to run it        and how to interpret the results.    -   Computation units are appropriately utilised during reasoning.

Learning

-   -   new information that is learnt is represented in a structured,        machine-readable representation of data that conforms to a        machine-readable language.    -   learning new information is obtained from automatically        processing the structured, machine-readable representation of        data to obtain, or learn, new information, and the new        information is itself represented as structured,        machine-readable representations of data that are stored in        memory.    -   Learning new information is obtained from a machine-learning        system which generates classifications or predictions or other        outputs which are represented as passages.    -   a machine-learning system processes the semantic nodes and        passages to obtain, or learn, new information.    -   new information is generated by automatically processing the        semantic nodes and passages to answer a question.    -   The method of any preceding Claim in which a question is        represented as one or more machine representations, such as        passages and a response to the question is automatically        generated using one or more of the following steps: (i) matching        the question with machine representations previously stored in a        memory store; (ii) fetching and executing one or more        computation units, where computation units represent        computational capabilities relevant to answering the        question; (iii) fetching and execution of one or more reasoning        machine representations, such as reasoning passages, which are        machine representations that represent the semantics of        potentially applicable reasoning steps relevant to answering the        question.    -   the new information represented as semantic nodes or passages        are stored and used to improve performance of learning new        facts.    -   the new information represented as semantic nodes or passages        are stored and used to improve reasoning steps.    -   the new information represented as semantic nodes or passages        are stored and used to explain or describe the new information        in natural language.    -   the new information represented as semantic nodes or passages        are stored and used in text or spoken conversations with human        users.    -   learning new information takes place from conversation with or        other natural language provided by human users, in which natural        language provided by users in spoken or written form is        translated into semantic nodes and passages and then new        information represented by these semantic nodes and passages is        stored and used.    -   learning takes place from reasoning, in which semantic nodes and        passages that are generated from a chain of reasoning steps, and        are stored and utilised.    -   learning takes place from natural language, in which by        translating all or parts of document sources of natural        language, such as web pages, scientific papers or other articles        into semantic nodes or passages, the resulting semantic nodes or        passages are then utilised by applications.    -   non-document sources of natural language, including audio        recordings or videos containing human speech, are used and        speech recognition technology is first utilised to create a text        transcription of the recordings of voice which are then        translated into semantic nodes and passages.    -   machine learning system is used to analyse document and        non-document data and create passages from that data.

Machine learning

-   -   a machine learning system is used to generate the semantic nodes        or passages that represent the words or sequence of words in a        natural language.    -   the machine learning system is a neural network system, such as        a deep learning system.    -   a neural architecture is used to generate the machine-readable        language.    -   the neural architecture utilises recurrent neural networks or        LSTMs or attention mechanisms or transformers.    -   the machine learning system has been trained on training data        comprising natural language and a corresponding structured        machine-readable representation, such as a machine-readable        language comprising semantic nodes and passages.    -   a passage of natural language is passed through a        sequence-to-sequence neural architecture trained on training        data comprising natural language and a corresponding structured        representation that encodes meaning.    -   the machine learning, e.g. neural network, system is a switch        transformer feed forward neural network system    -   the machine learning system, e.g. neural architecture, comprises        an encoder and decoder and beam searching is used during        decoding of the semantic representations from the decoder to        remove invalid semantic representations.    -   when automatically translating a sequence of words expressed in        the natural language, (such as speech or text input) into the        machine-readable language, the structure of the sequence of        words is compared with known machine-readable language        structures in the memory to identify similarities.    -   automatically translating the word or sequence of words (such as        speech or text input) into the machine-readable language is        achieved by referencing a store of previously identified correct        translations between the natural language and the        machine-readable language.    -   automatically translating the word or sequence of words (such as        speech or text input) into the machine-readable language is        achieved by utilising a pipeline of functions which transform        the word or sequence of words into a series of intermediate        forms.    -   the semantic impact of changes to the word or sequence of words        (such as speech or text input) in a natural language wording of        the translation in the natural language is automatically        assessed to determine whether known or ground truth examples of        semantic nodes or passages can be used that are sufficient        accurate.    -   the semantic nodes or passages that represent the words or        sequence of words (such as speech or text input) provides a        machine-readable representation of the meaning of the words or        sequence of words.    -   the semantic nodes or passages that represent the words or        sequence of words (such as speech or text input) are processed        by a computer-based system for one or more of the following: to        derive facts or relationships, to reason, to learn, to        translate, to answer questions, to process natural language        content, to enable man-machine interaction, to represent and to        police rules or tenets, to enable one or more vertical        applications.    -   the semantic nodes or passages that represent the words or        sequence of words (such as speech or text input) are processed        by a computer-based system to generate an output that is        human-readable.    -   the human readable output include one or more of the following:        an answer to a question expressed in the natural language; a        reasoning statement that explains how the system has reached a        conclusion; a learning statement that explains what the system        has learnt; a response in a man/machine interaction.    -   a neural net is trained end-to-end to turn audio or video data        directly into semantic nodes and passages.    -   natural language-based learning is combined with statistical        machine-learning to optimise the translation of document and        non-document data (such as speech or text input) into semantic        nodes and passages.    -   a machine learning system is used to generate the semantic nodes        or passages    -   the neural network system is a switch transformer feed forward        neural network system    -   structured data, such as the content of a table found in a        document or on the web, a spreadsheet or the content of a        relational, graph or other database is turned into semantic        nodes and passages by assigning semantic nodes to the        identifiers in the structured data and writing semantic nodes        and passages that correspond to the meaning of the structured        data.    -   learning takes place from analysis of other data, in which the        data is processed with an algorithm and the results of that        processing is represented in semantic nodes and passages.

Translation to and from UL

-   -   a word or sequence of words in a natural language is received        and automatically translated into the machine-readable language        by identifying or generating structured machine-readable        representations that semantically represent the meaning of the        word or sequence of word.    -   a machine learning system is used to generate the semantic nodes        or passages that represent the words or sequence of words in a        natural language.    -   the machine learning system is a neural network system, such as        a deep learning system.    -   a neural architecture is used to generate the machine-readable        language.    -   the neural architecture utilises recurrent neural networks or        LSTMs or attention mechanisms or transformers.    -   the machine learning system has been trained on training data        comprising natural language and a corresponding structured        machine-readable representation, such as a machine-readable        language comprising semantic nodes and passages.    -   a passage of natural language is passed through a        sequence-to-sequence neural architecture trained on training        data comprising natural language and a corresponding structured        representation that encodes meaning.    -   the neural network system is a switch transformer feed forward        neural network system.    -   the neural architecture comprises an encoder and decoder and        beam searching is used during decoding of the semantic        representations from the decoder to remove invalid semantic        representations.    -   the word or sequence of words in a natural language is a        question and the question is answered with reference to the        semantic representation.    -   the word or sequence of words in a natural language is one or        more documents and the semantic representation of the one or        more documents is used to answer question.    -   reasoning with reference to the semantic representation produces        further, new representations.    -   when automatically translating a sequence of words expressed in        the natural language into the machine-readable language, the        structure of the sequence of words is compared with known        machine-readable language structures in the memory to identify        similarities.    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by referencing a store of        previously identified correct translations between the natural        language and the machine-readable language.    -   automatically translating the word or sequence of words into the        machine-readable language is achieved by utilising a pipeline of        functions which transform the word or sequence of words into a        series of intermediate forms.    -   the semantic impact of changes to the word or sequence of words        in a natural language wording of the translation in the natural        language is automatically assessed to determine whether known or        ground truth examples of semantic nodes or passages can be used        that are sufficient accurate.    -   the semantic nodes or passages that represent the words or        sequence of words provides a machine-readable representation of        the meaning of the words or sequence of words.    -   the semantic nodes or passages that represent the words or        sequence of words are processed by a computer-based system for        one or more of the following: to derive facts or relationships,        to reason, to learn, to translate, to answer questions, to        process natural language content, to enable man-machine        interaction, to represent and to police rules or tenets, to        enable one or more vertical applications.    -   the semantic nodes or passages that represent the words or        sequence of words are processed by a computer-based system to        generate an output that is human-readable.    -   the human readable output include one or more of the following:        an answer to a question expressed in the natural language; a        reasoning statement that explains how the system has reached a        conclusion; a learning statement that explains what the system        has learnt; a response in a man/machine interaction.    -   The system is further operable to automatically translate from        the structured-machine readable representation to the natural        language.    -   When translating from the structured-machine readable        representation to the natural language the system varies the        generated translations between alternatives that are        substantially semantically equivalent to create varied and fresh        responses for the benefit of human users.    -   Automatically translating the word or sequence of words into the        machine-readable language is achieved by referencing a context        of information relevant to generating a correct translation.

Semantic Node Resolution

-   -   a service is provided that is operable to receive a description        of an entity and return one or more identifiers for structured,        machine-readable representations of data corresponding to the        entity, so that a user is able to use a shared identifier for        the entity.    -   the description is partially or fully described in the        machine-readable language.    -   the description is partially or fully written in one or more        natural languages.    -   the service compares the description of the proposed semantic        node or passages with available information about existing        entities to determine if there is a match.    -   the service probabilistically determines if there is a match.    -   the service additionally returns probabilities of matches along        with the one or more identifiers.    -   the service returns a new identifier if no match is found.

Tenets

-   -   the structured representation of data includes one or more        tenets, statements or other rules defining the objectives or        motives, also represented using the structured representation of        data; and a potential action is analysed to determine whether        executing the action would optimize or otherwise affect        achievement or realization of those tenets, statements or other        rules; and actions are selected, deciding on or executed only if        they optimize or otherwise positively affect the achievement or        realization of those tenets, statements or other rules.    -   actions that conform to the tenets, statements or other rules        (‘tenets’) are automatically proposed by referencing the tenets.    -   the actions include communicating with users in written form.    -   actions include communicating with users in spoken form.    -   the tenets include at least one measure the system should try to        maximise, such as user happiness.    -   the tenets include at least one measure the system should try to        minimise, such as user unhappiness.    -   the tenets include at least one rule for actions the system must        never do.    -   the system is further operable to avoid doing the actions the        system must never do by referencing the tenets.    -   the tenets include at least one suggestion of what action to do        in a defined circumstance.    -   the tenets include sub-tenets which are tenets that relate to        other tenets or which are more specific examples of another        tenet.    -   the actions include accessing other remote computer systems.    -   the actions include changing the state of devices linked to the        system via a network.    -   the actions include initiating a spoken interaction with a human        being.    -   a data store contains a machine-readable representation of the        world that encodes meaning and where the system is further        operable to reason with reference to the machine-readable        representation of the world to select actions that conform with        the tenets.    -   the machine-readable representation of the world comprises a        representation of valid reasoning steps and where the system is        further operable to utilise the representation of valid        reasoning steps to reason.    -   the machine-readable representation of the world includes a        representation of computational capabilities that are available        to the system and where the system is further operable to        utilise the computational capabilities by referencing the        machine-readable representation.    -   the system is operable to learn and augment the machine-readable        representation of the world.    -   the system is operable to learn from communication with at least        one user.    -   the system is operable to learn from at least one external        sensor connected to the system via a network.    -   the machine-readable tenets are at least partially represented        by combinations of identifiers and where at least some of the        identifiers represent concepts corresponding to real-world        things    -   the system is further operable to receive a description of a        concept from a remote system and use the description to return        an identifier which is likely to mean the concept.    -   the system is operable to continuously reason in a way that        results in actions that conform with the tenets.    -   the system is operable to answer questions about the tenets from        human users.    -   the computer system comprises a long-term memory; a short-term        memory; a tenet-store containing machine-readable tenets        representing rules to guide the system and where the computer        system is operable to receive events and utilise the events, the        contents of the long-term memory, the contents of the short-term        memory and the tenets to do actions that conform with the        tenets.    -   the computer system comprises a component which generates        candidate actions; a component that decides whether to execute        the candidate actions with reference to the tenets and a        component which executes actions.    -   answering a question asked by a human user comprises two        actions—generating a response to the question and communicating        that response to the human user.    -   the events include communication from at least one user and        where the actions include communication to at least one user.    -   the system is further operable to learn, and store what is has        learned to the long-term memory.    -   the computer system is not operable to change the tenets.    -   the tenets include a tenet prohibiting actions which might        result in changes to the tenets.    -   the system is further operable to do an independent check of        each potential action against the tenets and will discard the        potential action if the independent check finds that it is        incompatible with the tenets.    -   the computer system is further operable to actively exclude        knowledge on itself from being used in determining actions.    -   potential actions are autonomously generated by the computer        based system.    -   potential actions are autonomously generated by the computer        based system as outputs from processing inputs, such as audio or        text.    -   potential actions are autonomously generated with a process that        operates substantially continuously.    -   potential actions are autonomously generated without any        external trigger event to initiate processing or user        instruction or action to initiate processing.    -   the potential actions are automatically executed if they        optimize or otherwise positively affect the achievement or        realization of those tenets, statements or other rules.

1. A computer implemented method for the automated analysis or use ofdata, comprising the steps of: (a) storing in a memory a structured,machine-readable representation of data that conforms to amachine-readable language; where the data relates to product data,including one or more of: product descriptions, user product requests, auser's previous product-related search, social media or shoppinghistories; (b) automatically processing the structured machine-readablerepresentation of data to determine which products best match a user'sproduct requests or a user's previous search, social media or shoppinghistory.
 2. The method of claim 1 in which the structured,machine-readable representation of data that conforms to amachine-readable language comprises semantic nodes and passages; and inwhich a semantic node represents an entity and is itself represented byan identifier; and a passage is either (i) a semantic node or (ii) acombination of semantic nodes; and where machine-readable meaning comesfrom the choice of semantic nodes and the way they are combined andordered as passages.
 3. The method of claim 1 including the step ofpresenting products which are a best match to the user's productrequests or the user's previous search, social media or shoppinghistory.
 4. The method of claim 1 where the step of automaticallyprocessing the structured representation of data happens as part of anatural language conversation with the user about what product the useris looking to purchase.
 5. The method of claim 1 in which the structuredrepresentation of data further includes a representation of a spoken,written or GUI instruction provided by a human to a human/machineinterface.
 6. The method of claim 1 in which the representations ofproduct data have been automatically translated into the machinereadable language.
 7. The method of claim 2 in which a machine learningsystem is used to generate the semantic nodes or passages that are therepresentations of product data.
 8. The method of claim 7 in which themachine learning system is a neural network system, such as a deeplearning system, that is used to generate the machine-readable language.9. The method of claim 7 in which the machine learning system has beentrained on training data comprising natural language and a correspondingstructured machine-readable representation, such as a machine-readablelanguage comprising semantic nodes and passages.
 10. The method of claim1 in which a passage of natural language is passed through asequence-to-sequence neural architecture trained on training datacomprising natural language and a corresponding structuredrepresentation that encodes meaning.
 11. The method of claim 8 in whichthe neural network system utilises recurrent neural networks or LSTMs orattention mechanisms or transformers.
 12. The method of claim 8 in whichthe neural network system is a switch transformer feed forward neuralnetwork system.
 13. The method of claim 8 in which the neural networksystem comprises an encoder and decoder and beam searching is usedduring decoding of the semantic representations from the decoder toremove invalid semantic representations.
 14. The method of claim 1including the step of automatically translating a sequence of wordsexpressed in the natural language into the machine-readable language,and in which the structure of the sequence of words is compared withknown machine-readable language structures in the memory to identifysimilarities.
 15. The method of claim 1 including the step ofautomatically translating the word or sequence of words into themachine-readable language by referencing a store of previouslyidentified correct translations between the natural language and themachine-readable language.
 16. The method of claim 1 including the stepof automatically translating the word or sequence of words into themachine-readable language by utilising a pipeline of functions whichtransform the word or sequence of words into a series of intermediateforms.
 17. The method of claim 1 in which the machine-readable languageuses a single syntactical item, such as parentheses or brackets, todisambiguate the meaning of structured representations of data.
 18. Themethod of claim 1 in which the machine-readable language uses a sharedsyntax across factual statements, queries and reasoning.
 19. The methodof claim 1 in which the machine-readable language uses nesting of nodesand passages, as a substantially unambiguous syntax.
 20. The method ofclaim 1 in which the machine-readable language comprises a plurality ofidentifiers or IDs which are selected from an address space, such asUUID or Unicode, that is sufficiently large to enable users to select anew identifier with negligible risk of selecting a previously allocatedidentifier.
 21. The method of claim 1 in which the machine-readablelanguage is scalable since there are no restrictions on which users cancreate a structured, machine-readable representation of data or relatedidentifier.
 22. The method of claim 1 in which the machine-readablelanguage (i) uses a single syntactical item to disambiguate the meaningof structured representations of data; and (ii) uses a syntax that is asingle shared syntax that applies to passages that represent factualstatements, query statements and reasoning statements; and (iii) uses asyntax that is a substantially unambiguous syntax comprising nesting ofstructured representations of data; and (iv) uses an identifier selectedfrom an address space that is sufficiently large to enable users toselect a new identifier with negligible risk of selecting a previouslyallocated identifier; and (v) is scalable since there are norestrictions on which users can create a structured representations ofdata or related identifier.
 23. The method of claim 1 which includes thestep of (a) the machine-readable language representing a question in amemory as a structured, machine-readable representation of data; and themethod further includes the step of (b) automatically generating aresponse to the question, using one or more of the following steps: (i)matching the question with structured, machine-readable representationsof data previously stored in a memory store; (ii) fetching and executingone or more computation units, where computation units representcomputational capabilities relevant to answering the question; (iii)fetching and execution of one or more reasoning passages, which arestructured, machine-readable representations of data that represent thesemantics of potentially applicable reasoning steps relevant toanswering the question; and in which the representation of the question,the structured, machine-readable representations of data previouslystored in the memory store, the computation units and the reasoningpassages are all represented in substantially the same machine-readablelanguage.
 24. The method of claim 1 which includes the step of learningnew information and representing the new information in a structured,machine-readable representation of data that conforms to themachine-readable language.
 25. The method of claim 1 which includes thestep of (i) receiving a word or sequence of words in a natural language;and (ii) automatically translating that word or sequence of words intothe machine-readable language by identifying or generating structuredmachine-readable representations that semantically represent the meaningof the word or sequence of words in the machine-readable language. 26.The method of claim 1 which includes the step of providing a serviceoperable to receive a description of an entity and return one or moreidentifiers for structured, machine-readable representations of datacorresponding to the entity, so that a user is able to use a sharedidentifier for the entity.
 27. The method of claim 1 in which the methodenables translating between a first natural language and a secondnatural language, by: (a) storing in a memory a structured,machine-readable representation of data that conforms to amachine-readable language; (b) receiving a word or sequence of words inthe first natural language to be translated into the second naturallanguage; (c) automatically translating that word or sequence of wordsexpressed in the first natural language into the second natural languageby (i) identifying a structured, machine-readable representation of datathat represents the semantics of the word or sequence of words in thefirst natural language and (ii) retrieving a word or sequence of wordsin the second natural language that corresponds in meaning to theidentified structured, machine-readable representation of data.
 28. Themethod of claim 1 which includes the step of automatically andautonomously processing detected audio or text into the structuredrepresentation of data whenever audio or text is detected or received.29. The method of claim 1 which enables automatically selecting,deciding on or executing actions, and in which the structuredrepresentation of data includes one or more tenets, statements or otherrules defining the objectives or motives, also represented using thestructured representation of data; and the method further includes thesteps of (i) analysing a potential action to determine whether executingthe action would optimize or otherwise affect achievement or realizationof those tenets, statements or other rules; (ii) automaticallyselecting, deciding on or executing actions only if they optimize orotherwise positively affect the achievement or realization of thosetenets, statements or other rules.
 30. Computer-based system configuredto analyse data, the system being configured to: (a) store in a memory astructured, machine-readable representation of data that conforms to amachine-readable language; where the data relates to productdescriptions, user product requests, a user's previous search, socialmedia or shopping histories; (b) automatically process the structuredmachine-readable representation of data to determine which products bestmatch a user's product requests or a user's previous search, socialmedia or shopping history.